Bien démarrer avec les tests unitaires

Utilisez Visual Studio pour définir et exécuter des tests unitaires afin de maintenir l’intégrité du code, garantir la couverture du code, et rechercher les erreurs et les défauts avant que vos clients les trouvent. Exécutez vos tests unitaires fréquemment pour vérifier 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.

1. Ouvrez le projet que vous souhaitez tester dans Visual Studio.

   Dans le but de démontrer un exemple de test unitaire, cet article teste un simple projet de console C# ou C++ « Hello World » nommé HelloWorld. L’exemple de code pour un tel projet est comme suit :

   .NET

   namespace HelloWorld
   {
      public class Program
      {
         public static void Main()
         {
            Console.WriteLine("Hello World!");
         }
      }
   }
   

   C++

   #include <iostream>
   
   int main()
   {
      std::cout << "Hello World!\n";
   }
   

2. Dans l’Explorateur de solutions, sélectionnez le nœud de la solution. Ensuite, dans la barre de menus supérieure, sélectionnez Fichier>Ajouter>Nouveau projet.

3. Dans la boîte de dialogue nouveau projet, recherchez le projet de test unitaire à utiliser.

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

   À partir de la version 14.8 de Visual Studio 2017, les langages .NET 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 un autre cadre de test C++, consultez Écriture de tests unitaires pour C/C++). Pour Python, consultez Configurer des tests unitaires dans le code Python pour configurer votre projet de test.

   Conseil

   Pour C# uniquement, vous pouvez créer des projets de test unitaire à partir du code à l’aide d’une méthode plus rapide. Pour plus d’informations, consultez Créer des projets de test unitaire et des méthodes de test. Pour utiliser cette méthode avec .NET Core ou .NET Standard, Visual Studio 2019 ou une version ultérieure est nécessaire.

   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.

   

4. Dans le projet de test unitaire, ajoutez une référence au projet que vous voulez tester. Pour ce faire, faites un clic droit sur Références ou Dépendances, puis choisissez Ajouter une référence ou Ajouter une référence de projet.

5. Sélectionnez le projet qui contient le code que vous allez tester, puis cliquez sur OK.

   

6. 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 cadre de test : MSTest, NUnit ou xUnit (pris en charge uniquement sur .NET) ou C++ Microsoft Native Unit Test Framework.

   MSTest

   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);
            }
         }
      }
   }
   

   NUnit

   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);
            }
         }
      }
   }
   

   xUnit

   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);
               }
           }
       }
   }
   

   Infrastructure de test unitaire native Microsoft

   #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

1. Ouvrez l’Explorateur de tests.

   Pour ouvrir l’Explorateur de tests, choisissez Test>Explorateur de tests dans la barre de menus supérieure (ou appuyez sur Ctrl + E, T).

2. Exécutez vos tests unitaires en cliquant sur Tout exécuter (ou appuyez sur Ctrl + R, V).

   

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

   

Astuce

Vous pouvez utiliser l’Explorateur de tests pour exécuter des tests unitaires à partir du framework de tests intégré (MSTest) ou à partir de frameworks de tests tiers. Vous pouvez regrouper les tests en catégories, filtrer la liste de tests, ainsi que créer, enregistrer et exécuter des sélections de tests. Vous pouvez également déboguer des tests et analyser les performances des tests et la couverture du code.

Affichez les résultats des tests unitaires en direct (Visual Studio Enterprise)

Si vous utilisez le framework de tests MSTest, xUnit ou NUnit dans Visual Studio 2017 ou une version ultérieure, vous pouvez afficher les résultats temps réel de vos tests unitaires.

Notes

Pour suivre ces étapes, Visual Studio Enterprise est requis, ainsi que le code .NET et l’un des cadres de test suivants : MSTest, xUnit ou NUnit.

1. Activez les tests unitaires en direct à partir du menu Test en choisissant Test>Live Unit Testing>Démarrer.

   

2. Affichez les résultats des tests dans la fenêtre d’éditeur de code quand vous écrivez et modifiez le code.

   

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

   

Pour plus d’informations sur les tests unitaires en direct, consultez Tests unitaires en direct.

Utiliser un framework de tests tiers

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

• Utilisez le Gestionnaire de package NuGet pour installer le package NuGet pour le framework de votre choix.

• (.NET) À partir de Visual Studio 2017 version 14.6, Visual Studio inclut des modèles de projet de test préconfigurés pour les cadres 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 dans les versions ultérieures, certains cadres tels que Google C++ Testing Framework sont déjà inclus. Pour plus d’informations, consultez Écrire des tests unitaires pour C/C++ dans Visual Studio.

Ajoutez un projet de test unitaire :

1. Ouvrez la solution qui contient le code à tester.

2. Cliquez avec le bouton droit sur la solution dans l’Explorateur de solutions, puis choisissez Ajouter>Nouveau projet.

3. Sélectionnez un modèle de projet de test unitaire.

   Dans cet exemple, sélectionnez NUnit

   

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

   

4. Ajoutez une référence du projet de test au projet qui contient le code à tester.

   Cliquez avec le bouton droit sur le projet dans l’Explorateur de solutions, puis sélectionnez Ajouter>Référence. (Vous pouvez également ajouter une référence à partir du menu contextuel du nœud Références ou Dépendances.)

5. Ajoutez du code à votre méthode de test.

   

6. Exécutez le test à partir de l’Explorateur de tests, ou en faisant un clic droit sur le code de test et en choisissant Exécuter les tests (ou Ctrl + R, T).

Étapes suivantes

Concepts de base des tests unitaires

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

Écrire des tests unitaires pour C/C++