Démarrage rapide : développement piloté avec Test Explorer

Nous vous recommandons de créer des tests unitaires pour que votre code continue à s'exécuter correctement dans de nombreuses étapes incrémentielles de développement.Il existe plusieurs frameworks que vous pouvez utiliser pour écrire des tests unitaires, y compris ceux développés par des tiers.Certaines frameworks de test sont spécialisées à tester dans différentes langues ou plates-formes.L'explorateur de tests fournit une interface unique pour les tests unitaires dans l'un de ces frameworks.Les adaptateurs sont disponibles pour les frameworks les plus communément utilisées, et vous pouvez écrire vos propres adaptateurs pour d'autres frameworks.

L'explorateur de tests remplace les fenêtres de test unitaire trouvées dans les éditions antérieures de Visual Studio.Ses avantages incluent :

• Exécutez le .NET, le code non managé, la base de données et d'autres types de tests à l'aide d'une interface unique.

• Utilisez le framework de test unitaire de votre choix, comme NUnit ou MSTest.

• Consultez dans une fenêtre toutes les informations dont vous avez généralement besoin.Plus de détails sont accessibles dans la fenêtre Propriétés .

À l'aide de l'explorateur de tests

Pour exécuter des tests unitaires à l'aide de l'explorateur de tests

1. Créer des tests unitaires qui utilisent les frameworks de test de votre choix.

   Par exemple, pour créer un test qui utilise le framework MSTest :

   1. Créer un projet test.

      Dans la boîte de dialogue Nouveau projet, développez Visual Basic, Visual C#, ou Visual C++, puis choisissez Test.

      Sélectionnez Projet de test unitaire.

   2. Écrivez chaque test unitaire en tant que méthode.Ajoutez à chaque métode de test l'attribut [TestMethod].

2. Dans la barre de menus, sélectionnez Test, Exécutez les tests unitaires, Tous les tests.

   La solution se génère et le test s'exécute.

   L'explorateur de tests ouvre et affiche un résumé des résultats.

Pour afficher une liste complète des tests : Choisissez Afficher tout dans une catégorie.

Pour retourner au résumé, choisissez la vue ACCUEIL .

Pour afficher les détails d'un résultat de test : sélectionnez le test dans l'explorateur de tests.Des détails tels que les messages d'exception s'affichent dans le volet de détails.Vous pouvez également afficher davantage de détails dans la fenêtre Propriétés.

Double-cliquez surPour accéder au code d'un test : dans l'explorateur de tests, ou choisissez Ouvrir un test dans le menu contextuel.

Ouvrez le menu contextuel Pour déboguer un test : pour un ou plusieurs tests, puis choisissez Déboguer les tests sélectionnés.

Important

Les résultats affichés sont de l'exécution la plus récente.La barre colorée de résultats montre uniquement les résultats des tests qui ont été exécutés.Par exemple, si vous exécutez plusieurs tests et certains d'entre eux échouent, puis uniquement les tests réussis, la barre de résultats affiche tout vert.

[!REMARQUE]

Si aucun test n'apparaît, vérifiez que vous avez installé un adaptateur pour connecter l'explorateur de tests au framework de test que vous utilisez.Pour plus d'informations, consultez Utilisation de différentes infrastructures de test dans l'explorateur de tests.

Procédure pas à pas: Utilisation de Tests unitaires pour développer une méthode

Cette procédure pas-à-pas montre comment développer une méthode testée en C# à l'aide du framework de test unitaire Microsoft.Vous pouvez facilement l'adapter à d'autres langages, et utiliser d'autres frameworks de test telles que NUnit.Pour plus d'informations, consultez Utilisation de différents frameworks de Test.

Créer un test et la méthode

1. Créez un projet Bibliothèque de classes Visual C#.Ce projet contient le code que nous voulons délivrer.Dans cet exemple, il est nommé MyMath.

2. Créer un projet de test.

   • Dans la boîte de dialogue Nouveau projet, choisissez Visual C#, Test puis choisissez Projet de test unitaire.

     

3. Écrivez une méthode de test de base.Vérifiez le résultat obtenu pour une entrée spécifique :

     [TestMethod]
     public void BasicRooterTest()
     {
       // Create an instance to test:
       Rooter rooter = new Rooter();
       // Define a test input and output value:
       double expectedResult = 2.0;
       double input = expectedResult * expectedResult;
       // Run the method under test:
       double actualResult = rooter.SquareRoot(input);
       // Verify the result:
       Assert.AreEqual(expectedResult, actualResult,
           delta: expectedResult / 100);
     }
   

4. Générez la méthode de test.

   1. Placez le curseur sur Rooter, puis dans le menu contextuel, choisissez Générer, Nouveau type.

   2. Dans la boîte de dialogue Générer un nouveau type, affectez Projet au projet de Bibliothèque de classes.Dans cet exemple, il s'agit de MyMath.

   3. Placez le curseur sur SquareRoot, puis dans le menu contextuel, choisissez Générer, Méthode Stub.

5. Exécuter le test unitaire.

   • Dans le menu Test, choisissez Run Unit tests, Tous les tests.

     La solution se génère et s'exécute.

     L'explorateur de tests ouvre et affiche les résultats.

     Le test s'affiche sous Échec des Tests.

6. Sléectionnez le nom du test.

   Les détails du test s'affichent dans la partie inférieure de l'explorateur de tests.

7. Sélectionnez les éléments sous Trace de la pile pour voir où le test a échoué.

À ce stade, vous avez créé un test et un stub que vous avez modifié afin que le test réussisse.

Après chaque modification, faites en sorte que tous les tests passent

1. Dans MyMath\Rooter.cs, effectuez le code SquareRoot:

    public double SquareRoot(double input)
     {
       return input / 2;
     }
   

2. Dans l'explorateur de tests, sélectionnez Exécuter tout.

   Le code se génère et le test s'exécute.

   Le test est réussi.

   

Ajouter des tests pour étendre la plage d'entrées

1. Pour renforcer votre confiance dans le fonctionnemen de votre code dans tous les cas, ajouter des tests qui essaient un plus grand nombre de valeurs d'entrée.

   Conseil
   Évitez de modifier les tests existants qui réussissent.Au lieu de cela, ajoutez de nouveaux tests.Modifiez les tests existants uniquement lorsque les besoins des utilisateurs changent.Cette stratégie aide à garantir que vous ne perdez pas de fonctionnalités existantes à mesure que vous travaillez pour étendre le code.

   Dans votre classe de test, ajoutez le test suivant, qui tente une plage de valeurs d'entrée :

     [TestMethod]
     public void RooterValueRange()
     {
       // Create an instance to test:
       Rooter rooter = new Rooter();
       // Try a range of values:
       for (double expectedResult = 1e-8;
           expectedResult < 1e+8;
           expectedResult = expectedResult * 3.2)
       {
         RooterOneValue(rooter, expectedResult);
       }
     }
   
     private void RooterOneValue(Rooter rooter, double expectedResult)
     {
       double input = expectedResult * expectedResult;
       double actualResult = rooter.SquareRoot(input);
       Assert.AreEqual(expectedResult, actualResult,
           delta: expectedResult / 1000);
     }
   

2. Dans l'explorateur de tests, choisissez Tout exécuter.

   Le nouveau test échoue, bien que le premier test réussit toujours.

   Pour rechercher le point de défaillance, sélectionnez le test qui a échoué puis dans la partie inférieure de l'explorateur de tests, sélectionnez l'élément supérieur Trace de la pile.

3. Examinez la méthode de test pour voir ce qui peut être erroné.Dans la classe MyMath.Rooter, réécrivez le code :

     public double SquareRoot(double input)
     {
       double result = input;
       double previousResult = -input;
       while (Math.Abs(previousResult - result) > result / 1000)
       {
         previousResult = result;
         result = result - (result * result - input) / (2 * result);
       }
       return result;
     }
   

4. Dans l'explorateur de tests, choisissez Tout exécuter.

   Les deux tests ont réussi maintenant.

Ajouter des tests pour des cas exceptionnels

1. Ajouter un test pour les entrées négatives :

          [TestMethod]
           public void RooterTestNegativeInputx()
           {
               Rooter rooter = new Rooter();
               try
               {
                   rooter.SquareRoot(-10);
               }
               catch (ArgumentOutOfRangeException e)
               {
                   return;
               }
               Assert.Fail();
           }
   

2. Dans l'explorateur de tests, choisissez Tout exécuter.

   La méthode sous les boucles de test, et doit être annulée manuellement.

3. Sélectionnez Annuler.

   Le test s'arrête après 10 secondes.

4. Corrigez le code de la méthode :

     public double SquareRoot(double input)
     {
       if (input <= 0.0) 
       {
         throw new ArgumentOutOfRangeException();
       } 
     ...
   

5. Dans l'explorateur de test, choisissez Tout exécuter.

   Tous les tests réussissent.

Refactoriser sans modifier de tests

1. Simplifiez le code, mais ne modifiez pas les tests.

   Conseil

   La refactorisation est une modification qui est prévue pour que le code offre de meilleures performances ou pour simplifier la compréhension du code.Il n'est pas prévue de modifier le comportement du code, par conséquent, les tests ne sont pas modifiés. Nous vous recommandons d'effectuer les étapes de refactorisation séparément des étapes qui étendent les fonctionnalités.Conserver les tests non affectés vous permet de prendre acte comme quoi vous n'avez pas par erreur introduit des bogues lors de la refactorisation.

     public class Rooter
     {
       public double SquareRoot(double input)
       {
         if (input <= 0.0) 
         {
           throw new ArgumentOutOfRangeException();
         }
         double result = input;
         double previousResult = -input;
         while (Math.Abs(previousResult - result) > result / 1000)
         {
           previousResult = result;
           result = (result + input / result) / 2;
           //was: result = result - (result * result - input) / (2*result);
         }
         return result;
       }
     }
   

2. Choisissez Exécuter tout.

   Tous les tests réussissent toujours.