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.

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
- C++
```
namespace HelloWorld
{
   public class Program
   {
      public static void Main()
      {
         Console.WriteLine("Hello World!");
      }
   }
}
```
```
#include <iostream>

int main()
{
   std::cout << "Hello World!\n";
}
```
Selecteer in Solution Explorer het oplossingsknooppunt. Selecteer vervolgens in de bovenste menubalk de optie Nieuwproject.
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.

De .NET talen in Visual Studio ingebouwde sjablonen voor NUnit en xUnit bevatten. 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 Set up unit testing in Python code voor Python om uw testproject in te stellen.

Aanbeveling

In dit artikel wordt beschreven hoe u handmatig eenheidstests maakt. Als u automatisch tests wilt genereren op basis van bestaande code, raadpleegt u Eenheidstests genereren en uitvoeren met behulp van GitHub Copilot testen voor .NET of voor andere talen Slash-opdrachten gebruiken in GitHub Copilot

Aanbeveling

In dit artikel wordt beschreven hoe u handmatig eenheidstests maakt. Zie Een C#-unittestmethode stub maken vanuit code, of voor andere talen, Gebruik slasha-opdrachten in GitHub Copilot

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.
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.
Selecteer het project met de code die u gaat testen en klik op OK.

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

Eenheidstests uitvoeren

Open Test Explorer.

Als u Test Explorer wilt openen, kiest u TestExplorer in de bovenste menubalk (of drukt u op CtrlE, T).
Voer de eenheidstests uit door op Alles uitvoeren te klikken (of druk op CtrlR, V).

Schermopname van Test Explorer.

Eenheidstests uitvoeren in Test Explorer

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.

Schermopname van de resultaten van de eenheidstest in Test Explorer.

Testresultaten van eenheden controleren in Test Explorer

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.

Schakel live-eenheidstests uit in het menu Testen door TestLive Unit TestingStart te kiezen.
Bekijk de resultaten van de tests in het venster van de code-editor terwijl u code schrijft en bewerkt.

Schermopname van de resultaten van de tests.

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

Schermopname van de testresultatenindicatoren.

De indicatoren voor het testresultaat kiezen

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 de NuGet Pakketbeheer 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 Eenheidstests schrijven voor C/C++ in Visual Studio voor meer informatie.

Een eenheidstestproject toevoegen:

Open de oplossing die de code bevat die u wilt testen.
Klik met de rechtermuisknop op de oplossing in Solution Explorer en kies Toevoegen>Nieuw project.
Selecteer een eenheidstestprojectsjabloon.

In dit voorbeeld selecteert u NUnit

De projectsjabloon bevat NuGet-verwijzingen naar NUnit en NUnit3TestAdapter.
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 Toevoegen>Reference. (U kunt ook een verwijzing toevoegen vanuit het snelmenu van het knooppunt Verwijzingen of Afhankelijkheden .)
Voeg code toe aan uw testmethode.

Schermopname van code in het eenheidstestbestand.

Code toevoegen aan het testcodebestand van uw eenheid
Voer de test uit vanuit Test Explorer of klik met de rechtermuisknop op de testcode en kies Test(en) uitvoeren (of CtrlR, T).

Volgende stappen

Basisbeginselen van eenheidstests

Eenheidstests voor beheerde code maken en uitvoeren

schrijf eenheidstests voor C/C++

Feedback

Is deze pagina nuttig?

Last updated on 2026-03-06