Aan de slag met eenheidstests

Gebruik Visual Studio om eenheidstests te definiëren en uit te voeren om de codestatus te onderhouden, de codedekking te waarborgen en fouten en fouten te vinden voordat uw klanten dat doen. Voer uw eenheidstests regelmatig uit om ervoor te zorgen dat uw code goed werkt.

In dit artikel maakt de code gebruik van C# en C++, illustraties bevinden zich in C#, maar de concepten en functies zijn van toepassing op .NET-talen, C++, Python, JavaScript en TypeScript.

Eenheidstests maken

In deze sectie wordt beschreven hoe u een eenheidstestproject maakt.

1. Open het project dat u wilt testen in Visual Studio.

   Voor het demonstreren van een voorbeeldeenheidtest test dit artikel een eenvoudig 'Hallo wereld' C# of C++-consoleproject met de naam HelloWorld. De voorbeeldcode voor een dergelijk project is als volgt:

   .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. Selecteer in Solution Explorer het oplossingsknooppunt. Selecteer vervolgens in de bovenste menubalk de optie Nieuw>project>.

3. Zoek in het dialoogvenster Nieuw project het testproject voor eenheden dat u wilt gebruiken.

   Typ een test in het zoekvak om een projectsjabloon voor een eenheidstest te vinden voor het testframework dat u wilt gebruiken, zoals MSTest (C#) of het project Native Unit Test (C++) en selecteer deze.

   Vanaf Visual Studio 2017 versie 14.8 bevatten de .NET-talen ingebouwde sjablonen voor NUnit en xUnit. Voor C++ selecteert u in dit voorbeeld het project Systeemeigen eenheidstest , dat gebruikmaakt van Microsoft Native Unit Test Framework. (Als u een ander C++-testframework wilt gebruiken, raadpleegt u De schrijfeenheidtests voor C/C++). Zie Eenheidstests instellen in Python-code om uw testproject in te stellen voor Python.

   Aanbeveling

   Alleen voor C# kunt u eenheidstestprojecten maken op basis van code met behulp van een snellere methode. Zie Testprojecten en testmethoden voor eenheden maken voor meer informatie. Als u deze methode wilt gebruiken met .NET Core of .NET Standard, is Visual Studio 2019 of hoger vereist.

   In de volgende afbeelding ziet u een MSTest-eenheidstest, die wordt ondersteund in .NET.

   

   Klik op Volgende, kies een naam voor het testproject en klik vervolgens op Maken.

   Het project wordt toegevoegd aan uw oplossing.

   

4. Voeg in het eenheidstestproject een verwijzing toe naar het project dat u wilt testen door met de rechtermuisknop op Verwijzingen of afhankelijkheden te klikken en vervolgens Verwijzing toevoegen of Projectverwijzing toevoegen te kiezen.

5. Selecteer het project met de code die u gaat testen en klik op OK.

   

6. Voeg code toe aan de eenheidstestmethode.

   U kunt bijvoorbeeld de volgende code gebruiken door het juiste documentatietabblad te selecteren dat overeenkomt met uw testframework: MSTest, NUnit of xUnit (alleen ondersteund op .NET) of 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);
            }
         }
      }
   }
   

   Eenheid

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

   Microsoft Native Unit Test Framework

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

Eenheidstests uitvoeren

1. Open Test Explorer.

   Als u Test Explorer wilt openen, kiest u Test>Explorer in de bovenste menubalk (of drukt u op Ctrl + E, T).

2. Voer de eenheidstests uit door op Alles uitvoeren te klikken (of druk op Ctrl + R, V).

   

   Nadat de tests zijn voltooid, geeft een groen vinkje aan dat een test is geslaagd. Een rood x-pictogram geeft aan dat een test is mislukt.

   

Aanbeveling

U kunt Test Explorer gebruiken om eenheidstests uit te voeren vanuit het ingebouwde testframework (MSTest) of vanuit testframeworks van derden. U kunt tests groeperen in categorieën, de testlijst filteren en afspeellijsten van tests maken, opslaan en uitvoeren. U kunt ook fouten opsporen in tests en testprestaties en codedekking analyseren.

Live unit-testresultaten weergeven (Visual Studio Enterprise)

Als u het testframework MSTest, xUnit of NUnit gebruikt in Visual Studio 2017 of hoger, kunt u liveresultaten van uw eenheidstests zien.

Opmerking

Als u deze stappen wilt volgen, is Visual Studio Enterprise vereist, samen met .NET-code en een van de volgende testframeworks: MSTest, xUnit of NUnit.

1. Schakel live-eenheidstests uit in het menu Testen door Test>Live Unit Testing>Start te kiezen.

   

2. Bekijk de resultaten van de tests in het venster van de code-editor terwijl u code schrijft en bewerkt.

   

3. Klik op een testresultaatindicator voor meer informatie, zoals de namen van de tests die betrekking hebben op die methode.

   

Zie Live unit testing (Live unit testen) voor meer informatie over live-eenheidstests.

Een testframework van derden gebruiken

U kunt eenheidstests uitvoeren in Visual Studio met behulp van testframeworks van derden, zoals NUnit, Boost of Google C++ Testing Framework, afhankelijk van uw programmeertaal. Een framework van derden gebruiken:

• Gebruik NuGet Package Manager om het NuGet-pakket te installeren voor het framework van uw keuze.

• (.NET) Vanaf Visual Studio 2017 versie 14.6 bevat Visual Studio vooraf geconfigureerde testprojectsjablonen voor NUnit- en xUnit-testframeworks. De sjablonen bevatten ook de benodigde NuGet-pakketten om ondersteuning in te schakelen.

• (C++) In Visual Studio 2017 en latere versies zijn sommige frameworks zoals Google C++ Testing Framework al opgenomen. Zie voor meer informatie Eenheidstests schrijven voor C/C++ in Visual Studio.

Een eenheidstestproject toevoegen:

1. Open de oplossing die de code bevat die u wilt testen.

2. Klik met de rechtermuisknop op de oplossing in Solution Explorer en kiesNieuw project>.

3. Selecteer een eenheidstestprojectsjabloon.

   In dit voorbeeld selecteert u NUnit

   

   De projectsjabloon bevat NuGet-verwijzingen naar NUnit en NUnit3TestAdapter.

   

4. Voeg een verwijzing uit het testproject toe aan het project met de code die u wilt testen.

   Klik met de rechtermuisknop op het project in Solution Explorer en selecteer Verwijzing toevoegen>. (U kunt ook een verwijzing toevoegen vanuit het snelmenu van het knooppunt Verwijzingen of Afhankelijkheden .)

5. Voeg code toe aan uw testmethode.

   

6. Voer de test uit vanuit Test Explorer of klik met de rechtermuisknop op de testcode en kies Test(en) uitvoeren (of Ctrl + R, T).

Volgende stappen

Basisbeginselen van eenheidstests

Eenheidstests voor beheerde code maken en uitvoeren

schrijf eenheidstests voor C/C++