Commencez avec les tests unitaires

Utilisez Visual Studio pour définir et exécuter des tests unitaires pour maintenir l’intégrité du code, garantir la couverture du code et rechercher des erreurs et des erreurs avant que vos clients ne le fassent. Exécutez fréquemment vos tests unitaires pour vous assurer que votre code fonctionne correctement.

Dans cet article, le code utilise C# et C++, les illustrations sont en C#, mais les concepts et fonctionnalités s’appliquent aux langages .NET, C++, Python, JavaScript et TypeScript.

Créer des tests unitaires

Cette section explique comment créer un projet de test unitaire.

Ouvrez le projet que vous souhaitez tester dans Visual Studio.

Dans le cadre de la démonstration d’un exemple de test unitaire, cet article teste un projet de console C# ou C+ Hello World simple nommé HelloWorld. L’exemple de code d’un tel projet est le suivant :
- .NET
- C++
```
namespace HelloWorld
{
   public class Program
   {
      public static void Main()
      {
         Console.WriteLine("Hello World!");
      }
   }
}
```
```
#include <iostream>

int main()
{
   std::cout << "Hello World!\n";
}
```
Dans Explorateur de solutions, sélectionnez le nœud de solution. Ensuite, dans la barre de menus supérieure, sélectionnez FichierAjouterun nouveau projet.
Dans la boîte de dialogue nouveau projet, recherchez le projet de test unitaire à utiliser.

Tapez un test dans la zone de recherche pour rechercher un modèle de projet de test unitaire pour l’infrastructure de test que vous souhaitez utiliser, par exemple MSTest (C#) ou le projet de test unitaire natif (C++), puis sélectionnez-le.

Les langages .NET dans Visual Studio incluent des modèles intégrés pour NUnit et xUnit. Pour C++, dans cet exemple, sélectionnez le projet de test unitaire natif , qui utilise Microsoft Native Unit Test Framework. (Pour utiliser une autre infrastructure de test C++, consultez Écriture de tests unitaires pour C/C++). Pour Python, consultez Set up unit testing in Python code pour configurer votre projet de test.

Conseil / Astuce

Cet article explique comment créer manuellement des tests unitaires. Si vous souhaitez générer automatiquement des tests à partir du code existant, consultez Generate et exécutez des tests unitaires à l’aide de GitHub Copilot test pour .NET ou pour d’autres langues, voir Utiliser les commandes de barre oblique dans GitHub Copilot

Conseil / Astuce

Cet article explique comment créer manuellement des tests unitaires. Si vous souhaitez générer automatiquement des tests à partir du code existant, consultez Créer des squelettes de méthodes de test unitaires C# à partir du code, ou pour d'autres langages, voir Utiliser les commandes slash dans GitHub Copilot

L’illustration suivante montre un test unitaire MSTest, pris en charge dans .NET.

Cliquez sur Suivant, choisissez un nom pour le projet de test, puis cliquez sur Créer.

Le projet est ajouté à votre solution.
Dans le projet de test unitaire, ajoutez une référence au projet que vous souhaitez tester en cliquant avec le bouton droit sur Références ou Dépendances , puis en choisissant Ajouter une référence ou Ajouter une référence de projet.
Sélectionnez le projet qui contient le code que vous allez tester, puis cliquez sur OK.

Ajoutez du code à la méthode de test unitaire.

Par exemple, vous pouvez utiliser le code suivant en sélectionnant l’onglet de documentation approprié qui correspond à votre infrastructure de test : MSTest, NUnit ou xUnit (pris en charge uniquement sur .NET) ou C++ Microsoft Native Unit Test Framework.

MSTest
NUnit
xUnit
Microsoft Native Unit Test Framework

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.IO;
using System;

namespace HelloWorldTests
{
   [TestClass]
   public class UnitTest1
   {
      private const string Expected = "Hello World!";
      [TestMethod]
      public void TestMethod1()
      {
         using (var sw = new StringWriter())
         {
            Console.SetOut(sw);
            HelloWorld.Program.Main();

            var result = sw.ToString().Trim();
            Assert.AreEqual(Expected, result);
         }
      }
   }
}

using NUnit.Framework;
using System.IO;
using System;

namespace HelloWorldTests
{
   public class Tests
   {
      private const string Expected = "Hello World!";

      [SetUp]
      public void Setup()
      {
      }
      [Test]
      public void TestMethod1()
      {
         using (var sw = new StringWriter())
         {
            Console.SetOut(sw);
            HelloWorld.Program.Main();

            var result = sw.ToString().Trim();
            Assert.AreEqual(Expected, result);
         }
      }
   }
}

using System;
using Xunit;
using System.IO;

namespace HelloWorldTests
{
    public class UnitTest1
    {
        private const string Expected = "Hello World!";
        [Fact]
        public void Test1()
        {
            using (var sw = new StringWriter())
            {
                Console.SetOut(sw);
                HelloWorld.Program.Main();

                var result = sw.ToString().Trim();
                Assert.Equal(Expected, result);
            }
        }
    }
}

#include "pch.h"
#include "CppUnitTest.h"
#include "../HelloWorldUnitTestCPP/HelloWorldUnitTestCPP.cpp"   // Update using your project name

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

namespace HelloWorldTests
{
   TEST_CLASS(HelloWorldTests)
   {
   public:

      TEST_METHOD(TestMethod)
      {
         std::string expected = "Hello World!\n";

         std::stringstream buffer;
         std::streambuf* sbuf = std::cout.rdbuf(); // Save cout's buffer
         std::cout.rdbuf(buffer.rdbuf()); // Redirect cout to the stringstream buffer

         // Call main() in your test
         int result = main();

         // When finished, redirect cout to the original buffer 
         std::cout.rdbuf(sbuf);
         std::cout << "std original buffer: \n";
         std::cout << buffer.get();

         // Test
         Assert::AreEqual(expected, buffer.str());
      }
   };
}

Exécuter des tests unitaires

Ouvrez l’Explorateur de tests.

Pour ouvrir l’Explorateur de tests, choisissez l’Explorateurde tests dans la barre de menus supérieure (ou appuyez sur CtrlE, T).
Exécutez vos tests unitaires en cliquant sur Exécuter tout (ou appuyez sur CtrlR, V).

Capture d’écran montrant l’Explorateur de tests.

Exécuter des tests unitaires dans l’Explorateur de tests

Une fois les tests terminés, une coche verte indique qu’un test a réussi. Une icône rouge « x » indique qu’un test a échoué.

Capture d’écran montrant les résultats des tests unitaires dans l’Explorateur de tests.

Passer en revue les résultats des tests unitaires dans l’Explorateur de tests

Conseil / Astuce

Vous pouvez utiliser l’Explorateur de tests pour exécuter des tests unitaires à partir de l’infrastructure de test intégrée (MSTest) ou à partir d’infrastructures de test tierces. Vous pouvez regrouper des tests en catégories, filtrer la liste de tests et créer, enregistrer et exécuter des playlists de tests. Vous pouvez également déboguer des tests et analyser les performances des tests et la couverture du code.

Afficher les résultats des tests unitaires en direct (Visual Studio Entreprise)

Si vous utilisez l’infrastructure de test MSTest, xUnit ou NUnit dans Visual Studio 2017 ou version ultérieure, vous pouvez voir les résultats en direct de vos tests unitaires.

Note

Pour suivre ces étapes, Visual Studio Entreprise est nécessaire, ainsi que .NET code et l’une des infrastructures de test suivantes : MSTest, xUnit ou NUnit.

Activez les tests unitaires en direct à partir du menu Test en choisissant Test.
Affichez les résultats des tests dans la fenêtre de l’éditeur de code lorsque vous écrivez et modifiez du code.

Capture d’écran montrant les résultats des tests.

Afficher les résultats des tests
Cliquez sur un indicateur de résultat de test pour afficher plus d’informations, telles que les noms des tests qui couvrent cette méthode.

Capture d’écran montrant les indicateurs de résultats de test.

Choisir les indicateurs de résultat de test

Pour plus d’informations sur les tests unitaires en direct, consultez Live Unit Testing.

Utiliser une infrastructure de test tierce

Vous pouvez exécuter des tests unitaires dans Visual Studio à l’aide de frameworks de test tiers tels que NUnit, Boost ou Google C++ Testing Framework, en fonction de votre langage de programmation. Pour utiliser une infrastructure tierce :

Utilisez le NuGet Gestionnaire de package pour installer le package NuGet pour l’infrastructure de votre choix.
(.NET) À compter de Visual Studio 2017 version 14.6, Visual Studio inclut des modèles de projet de test préconfigurés pour les frameworks de test NUnit et xUnit. Les modèles incluent également les packages NuGet nécessaires pour activer la prise en charge.
(C++) Dans Visual Studio 2017 et versions ultérieures, certaines infrastructures telles que Google C++ Testing Framework sont déjà incluses. Pour plus d’informations, consultez Write des tests unitaires pour C/C++ dans Visual Studio.

Pour ajouter un projet de test unitaire :

Ouvrez la solution qui contient le code que vous souhaitez tester.
Cliquez avec le bouton droit sur la solution dans Explorateur de solutions et choisissez Add>New Project.
Sélectionnez un modèle de projet de test unitaire.

Dans cet exemple, sélectionnez NUnit

modèle de projet de test

Le modèle de projet inclut des références NuGet à NUnit et NUnit3TestAdapter.

dépendances
Ajoutez une référence du projet de test au projet qui contient le code que vous souhaitez tester.

Cliquez avec le bouton droit sur le projet dans Explorateur de solutions, puis sélectionnez Add>Reference. (Vous pouvez également ajouter une référence dans le menu contextuel du nœud Références ou Dépendances .)
Ajoutez du code à votre méthode de test.

Capture d’écran montrant le code dans le fichier de test unitaire.

Ajouter du code à votre fichier de code de test unitaire
Exécutez le test à partir de l’Explorateur de tests ou en cliquant avec le bouton droit sur le code de test et en choisissant Exécuter des tests (ou CtrlR, T).

Étapes suivantes

Principes de base des tests unitaires

Créer et exécuter des tests unitaires pour le code managé

Écrire des tests unitaires pour le code C/C++

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-03-06