Erste Schritte mit Komponententests

Verwenden Sie Visual Studio, um Komponententests zu definieren und auszuführen, um codeintegrität zu gewährleisten, Codeabdeckung sicherzustellen und Fehler und Fehler zu finden, bevor Ihre Kunden dies tun. Führen Sie Die Komponententests häufig aus, um sicherzustellen, dass Ihr Code ordnungsgemäß funktioniert.

In diesem Artikel verwendet der Code C# und C++, Abbildungen sind in C# enthalten, aber die Konzepte und Features gelten für .NET Sprachen, C++, Python, JavaScript und TypeScript.

Erstellen von Komponententests

In diesem Abschnitt wird beschrieben, wie Sie ein Komponententestprojekt erstellen.

1. Öffnen Sie das Projekt, das Sie in Visual Studio testen möchten.

   Zur Veranschaulichung eines Beispieleinheitstests testet dieser Artikel ein einfaches Hallo Welt C#- oder C++-Konsolenprojekt mit dem Namen HelloWorld. Der Beispielcode für ein solches Projekt lautet wie folgt:

   .NET

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

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

2. Wählen Sie in Projektmappen-Explorer den Lösungsknoten aus. Wählen Sie dann in der oberen Menüleiste DateiHinzufügenNeues Projekt aus.

3. Suchen Sie im Dialogfeld "Neues Projekt" das zu verwendende Komponententestprojekt.

   Geben Sie den Test in das Suchfeld ein, um eine Komponententestprojektvorlage für das testframework zu finden, das Sie verwenden möchten, z. B. MSTest (C#) oder das Native Unit Test-Projekt (C++), und wählen Sie sie aus.

   Die .NET Sprachen in Visual Studio enthalten integrierte Vorlagen für NUnit und xUnit. Für C++ wählen Sie in diesem Beispiel das Native Unit Test-Projekt aus, das Microsoft Native Unit Test Framework verwendet. (Informationen zum Verwenden eines anderen C++-Testframeworks finden Sie unter Schreiben von Komponententests für C/C++). Informationen zu Python finden Sie unter Einrichten von Komponententests in Python-Code, um Ihr Testprojekt einzurichten.

   Tipp

   In diesem Artikel wird beschrieben, wie Sie Komponententests manuell erstellen. Wenn Sie Tests automatisch aus bestehendem Code generieren möchten, lesen Sie Generieren und Ausführen von Komponententests mithilfe von GitHub Copilot-Tests für .NET, oder für andere Sprachen lesen Sie Verwenden Sie Slash-Befehle in GitHub Copilot.

   Die folgende Abbildung zeigt einen MSTest-Komponententest, der in .NET unterstützt wird.

   

   Klicken Sie auf "Weiter", wählen Sie einen Namen für das Testprojekt aus, und klicken Sie dann auf "Erstellen".

   Das Projekt wird Ihrer Projektmappe hinzugefügt.

   

4. Fügen Sie im Komponententestprojekt einen Verweis auf das Projekt hinzu, das Sie testen möchten, indem Sie mit der rechten Maustaste auf Verweise oder Abhängigkeiten klicken und dann " Verweis hinzufügen" oder " Projektverweis hinzufügen" auswählen.

5. Wählen Sie das Projekt aus, das den Code enthält, den Sie testen möchten, und klicken Sie auf "OK".

   

6. Fügen Sie der Komponententestmethode Code hinzu.

   Sie können beispielsweise den folgenden Code verwenden, indem Sie die richtige Dokumentationsregisterkarte auswählen, die Ihrem Testframework entspricht: MSTest, NUnit oder xUnit (nur für .NET unterstützt) oder das C++ 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());
         }
      };
   }
   

Ausführen von Komponententests

1. Öffnen Sie den Test-Explorer.

   Um den Test-Explorer zu öffnen, wählen Sie in der oberen Menüleiste denTest-Explorer aus (oder drücken Sie STRG-E, T).

2. Führen Sie die Unit-Tests aus, indem Sie auf „Alle ausführen“ klicken (oder STRGR, V drücken).

   Screenshot des Test-Explorers.

   Nach Abschluss der Tests weist ein grünes Häkchen darauf hin, dass ein Test bestanden wurde. Ein rotes "x"-Symbol gibt an, dass ein Test fehlgeschlagen ist.

   Screenshot mit Komponententestergebnissen im Test-Explorer.

Tipp

Sie können Test-Explorer verwenden, um Komponententests aus dem integrierten Testframework (MSTest) oder von Drittanbieter-Testframeworks auszuführen. Sie können Tests in Kategorien gruppieren, die Testliste filtern und Wiedergabelisten von Tests erstellen, speichern und ausführen. Sie können auch Tests debuggen und die Testleistung und Codeabdeckung analysieren.

Anzeigen der Live-Einheitstestergebnisse (Visual Studio Enterprise)

Wenn Sie das MSTest-, xUnit- oder NUnit-Testframework in Visual Studio 2017 oder höher verwenden, können Sie live Ergebnisse Ihrer Komponententests sehen.

Hinweis

Um diese Schritte auszuführen, ist Visual Studio Enterprise zusammen mit .NET Code und einem der folgenden Testframeworks erforderlich: MSTest, xUnit oder NUnit.

1. Schalten Sie die Live-Einheitentests über das Menü Test ein, indem Sie TestLive-EinheitentestsStarten auswählen.

   

2. Zeigen Sie die Ergebnisse der Tests im Code-Editor-Fenster an, während Sie Code schreiben und bearbeiten.

   Screenshot, der die Ergebnisse der Tests zeigt.

3. Klicken Sie auf einen Testergebnisindikator, um weitere Informationen anzuzeigen, z. B. die Namen der Tests, die diese Methode abdecken.

   Screenshot der Testergebnisindikatoren.

Weitere Informationen zu Live-Komponententests finden Sie unter Live-Komponententests.

Verwenden eines Drittanbietertestframeworks

Sie können Komponententests in Visual Studio ausführen, indem Sie abhängig von Ihrer Programmiersprache Testframeworks von Drittanbietern wie NUnit, Boost oder Google C++-Testframework verwenden. So verwenden Sie ein Drittanbieterframework:

• Verwenden Sie das NuGet-Paket-Manager, um das NuGet-Paket für das Framework Ihrer Wahl zu installieren.

• (.NET) Ab Visual Studio 2017, Version 14.6, enthält Visual Studio vorkonfigurierte Testprojektvorlagen für NUnit- und xUnit-Testframeworks. Die Vorlagen enthalten auch die erforderlichen NuGet-Pakete, um die Unterstützung zu aktivieren.

• (C++) In Visual Studio 2017 und höheren Versionen sind bereits einige Frameworks wie Google C++-Testframework enthalten. Weitere Informationen finden Sie unter Unittests für C/C++ in Visual Studio erstellen.

So fügen Sie ein Komponententestprojekt hinzu:

1. Öffnen Sie die Projektmappe, die den Code enthält, den Sie testen möchten.

2. Klicken Sie mit der rechten Maustaste auf die Lösung in Projektmappen-Explorer und wählen Sie Add>Neues Projekt aus.

3. Wählen Sie eine Komponententestprojektvorlage aus.

   Wählen Sie in diesem Beispiel "NUnit" aus.

   

   Die Projektvorlage enthält NuGet-Verweise auf NUnit und NUnit3TestAdapter.

   

4. Fügen Sie dem Projekt einen Verweis aus dem Testprojekt hinzu, der den code enthält, den Sie testen möchten.

   Klicken Sie mit der rechten Maustaste auf das Projekt in Projektmappen-Explorer, und wählen Sie dann Add>Reference aus. (Sie können auch einen Verweis aus dem Kontextmenü des Knotens "Verweise" oder "Abhängigkeiten" hinzufügen.)

5. Fügen Sie Ihrer Testmethode Code hinzu.

   Screenshot, der Code in der Komponententestdatei zeigt.

6. Führen Sie den Test im Test-Explorer aus, oder klicken Sie mit der rechten Maustaste auf den Testcode, und wählen Sie "Test(n) ausführen " (oder STRGR, T).

Nächste Schritte

Unittest-Grundlagen

Erstellen und Ausführen von Komponententests für verwalteten Code

Schreiben von Komponententests für C/C++-