Schnellstart: Testgesteuerte Entwicklung mit dem Test-Explorer

Wir empfehlen das Erstellen von Komponententests, um Ihren Code ordnungsgemäß funktioniert, durch viele aufeinander aufbauende Schritte der Entwicklung zu halten.Es gibt mehrere Frameworks, die Sie zum Schreiben von Komponententests, darunter einige von Drittanbietern entwickelte verwenden können.Einige Test-Frameworks sind zum Testen in verschiedenen Sprachen und Plattformen spezialisiert.Test-Explorer bietet eine einzige Schnittstelle für Komponententests in eines dieser Frameworks.Für die am häufigsten verwendeten Frameworks sind Adapter erhältlich, und Sie können eigene Adapter für andere Frameworks schreiben.

Test-Explorer ersetzt die Unit Test-Fenster in früheren Versionen des Visual Studio gefunden.Ihre Vorteile:

• Ausführen.NET, nicht verwalteten, Datenbank und andere Arten von Tests, die über eine einzige Schnittstelle.

• Verwenden Sie Komponententestframeworks Ihrer Wahl, wie z. B. NUnit oder MSTest-Frameworks.

• Finden Sie in einem Fenster alle Informationen, die Sie in der Regel benötigen.Weitere Informationen finden Sie in der Eigenschaften Fenster.

Mit dem Test-Explorer

Zum Ausführen von Komponententests mit Test-Explorer

1. Erstellen von Komponententests, die die Test-Frameworks Ihrer Wahl verwenden.

   Erstellen Sie einen Test verwendet, die das MSTest-Framework

   1. Erstellen Sie ein Testprojekt.

      In der Neues Projekt Dialogfeld erweitern Sie Visual Basic, Visual C#-, oder Visual C++, und wählen Sie Test.

      Wählen Sie Komponententestprojekt.

   2. Schreiben Sie jeder Komponententest wird als eine Methode.Jeder Testmethode mit Präfix der [TestMethod] Attribut.

2. Wählen Sie auf der Menüleiste Test, Komponententests ausführen, Alle Tests.

   Die Projektmappe erstellt wurde, und die Tests ausgeführt.

   Test-Explorer wird geöffnet und zeigt eine Zusammenfassung der Ergebnisse.

Um eine vollständige Liste der Tests finden Sie unter: auswählen Alle anzeigen in jeder Kategorie.

Wenn Sie zur Zusammenfassung zurückkehren möchten, wählen Sie die HOME anzeigen.

Um sich von einem Testergebnis: wählen Sie den Test im Explorer testen.Im Detailbereich werden Informationen wie z. B. Ausnahmemeldungen angezeigt.Sie können auch weitere Details im Fenster Eigenschaften sehen.

Navigieren Sie zu der Code für einen Test: doppelklicken Sie auf den Test im Explorer testen, oder wählen Sie Open testen im Kontextmenü auf.

So debuggen Sie einen Test: öffnen Sie das Kontextmenü für einen oder mehrere Tests, und wählen Sie dann Ausgewählten Tests Debuggen.

Wichtig
Sind die angezeigten Ergebnisse werden für die letzten ausgeführt.Der farbige Ergebnisse-Balken zeigt die Ergebnisse der Tests, die ausgeführt wurde.Beispielsweise wenn Sie mehrere Tests ausführen und einige davon fehl, und dann nur die erfolgreichen Tests ausführen, zeigen dann die Ergebnisse Bar alle grünen.

Hinweis
Wenn kein Test angezeigt wird, stellen Sie sicher, dass Sie einen Adapter Explorer Testen des Test-Frameworks, die Sie installiert haben.Weitere Informationen finden Sie unter Mithilfe von verschiedenen Test-Frameworks mit Test-Explorer.

Exemplarische Vorgehensweise: Entwickeln eine Methode mithilfe von Komponententests

In dieser exemplarischen Vorgehensweise veranschaulicht, wie eine bewährte Methode in c# mithilfe das Microsoft-Komponententest-Framework entwickeln.Sie können leicht es für andere Sprachen und andere Test-Frameworks wie NUnit verwenden anpassen.Weitere Informationen finden Sie unter Unter Verwendung der verschiedenen Test-Frameworks.

Erstellen der Test und die Methode

1. Erstellen Sie ein Visual C#-Klassenbibliotheksprojekt.Dieses Projekt enthält den Code, den wir liefern möchten.In diesem Beispiel heißt es MyMath.

2. Erstellen Sie ein Testprojekt.

   • In der Neues Projekt Dialogfeld, wählen Sie Visual C#-, Test und wählen Sie Testprojekt Einheit.

     

3. Schreiben Sie eine einfache Testmethode.Überprüfen Sie das Ergebnis für eine bestimmte Eingabe:

     [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. Generieren Sie die Methode aus dem Test.

   1. Platzieren Sie den Cursor auf Rooter, und wählen Sie dann im Kontextmenü auf generieren, Neue Art.

   2. In der Generieren neuer Typ Dialogfeld, Set Projekt auf das Klassenbibliotheksprojekt.In diesem Beispiel ist es MyMath.

   3. Platzieren Sie den Cursor auf SquareRoot, und wählen Sie dann im Kontextmenü auf generieren, Methodenstub.

5. Führen Sie den Komponententest.

   • Auf der Test im Menü Wählen Sie Komponententests ausführen, Alle Tests.

     Die Projektmappe erstellt und ausgeführt wird.

     Test-Explorer wird geöffnet und zeigt die Ergebnisse.

     Der Test wird unter Tests fehlgeschlagen.

6. Wählen Sie den Namen des Tests.

   Die Details des Tests werden im unteren Teil des Explorers testen.

7. Wählen Sie die Elemente unter Stack-Trace zu sehen, wo der Test ist fehlgeschlagen.

Zu diesem Zeitpunkt haben Sie erstellt einen Test und einen Stub, den Sie ändern werden, so dass der Test bestanden.

Stellen Sie nach jeder Änderung der Tests, die übergeben

1. In MyMath\Rooter.cs, verbessern Sie den Code des SquareRoot:

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

2. Wählen Sie Test-Explorer Alles.

   Der Code erstellt und der Test ausgeführt wird.

   Der Test wurde erfolgreich ausgeführt.

   

Hinzufügen von Tests zur Erweiterung des Umfangs der Eingänge

1. Um Ihr Vertrauen zu verbessern, das Ihren Code in allen Fällen arbeitet, Hinzufügen von Tests, die eine größere Eingabewerte zu versuchen.

   Tipp
   Zu vermeiden, ändern vorhandene Tests, die übergeben.Stattdessen fügen Sie neue Tests.Ändern Sie vorhandene Tests nur, wenn die Benutzeranforderungen ändern.Diese Richtlinie verhindert, dass vorhandene Funktionalität nicht verlieren, während Sie arbeiten, um den Code zu erweitern.

   Fügen Sie in Ihrem Test-Klasse den folgenden Test, der versucht, einen Bereich von Eingabewerten:

     [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. Wählen Sie Test-Explorer Alles.

   Der neue Test fehlschlägt, obwohl noch den ersten Test bestehen.

   Um die Fehlerquelle zu finden, wählen Sie den fehlgeschlagenen Test, und wählen Sie dann im unteren Teil des Test-Explorers das oberste Element von der Stack-Trace.

3. Überprüfen Sie die Methode unter Testen, um festzustellen, was falsch sein könnte.In der MyMath.Rooter -Klasse, die den Code neu schreiben:

     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. Wählen Sie Test-Explorer Alles.

   Jetzt können Sie beide Tests bestehen.

Hinzufügen von Tests für Ausnahmefälle

1. Fügen Sie einen Test für negative Eingänge:

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

2. Wählen Sie Test-Explorer Alles.

   Die Methode unter Testen von Loops und muss manuell aufgehoben werden.

3. Wählen Sie stornieren.

   Der Test wird nach 10 Sekunden beendet.

4. Korrigieren Sie den Methodencode für die:

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

5. Wählen Sie Test-Explorer Alles.

   Alle Tests bestehen.

Ohne Tests Umgestalten

1. Vereinfachen Sie den Code, aber ändern Sie die Tests nicht.

   Tipp

   A Umgestaltung ist eine Änderung, die den Code besser zu machen oder den Code leichter verständlich machen soll.Es soll nicht das Verhalten des Codes ändern, und daher die Tests werden nicht geändert. Wir empfehlen Sie refactoring Schritte separat aus Schritte durchführen, die Funktionalität zu erweitern.Halten die Tests unverändert gibt Ihnen vertrauen, dass Sie Fehler versehentlich nicht beim refactoring eingeführt haben.

     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. Wählen Sie laufen alle.

   Alle Tests bestehen weiterhin.