Zelfstudie: Een .NET-klassebibliotheek testen

Deze zelfstudie laat zien hoe u eenheidstests automatiseert door een testproject toe te voegen aan een oplossing.

Vereiste voorwaarden

Deze handleiding werkt met de oplossing die u in Maak een .NET classbibliotheek creëert.

Een eenheidstestproject maken

Eenheidstests bieden geautomatiseerde softwaretests tijdens uw ontwikkeling en publicatie. MSTest is een van de drie testframeworks waaruit u kunt kiezen. De andere zijn xUnit en nUnit.

Start Visual Studio.
Open de ClassLibraryProjects-oplossing die u hebt gemaakt in Maak een .NET-klassebibliotheek.
Voeg een nieuw eenheidstestproject met de naam StringLibraryTest toe aan de oplossing.
1. Klik met de rechtermuisknop op de oplossing in Solution Explorer en selecteer Toevoegen>Nieuw project.
2. Voer op de pagina Een nieuw project toevoegenmstest in het zoekvak in. Kies C# of Visual Basic in de lijst Taal en kies vervolgens Alle platforms in de lijst Platform.
3. Kies de sjabloon MSTest Test Project en kies vervolgens Volgende.
4. Voer op de pagina Uw nieuwe project configurerenStringLibraryTest in het vak Projectnaam in. Kies Volgende om door te gaan.
5. Selecteer op de pagina Aanvoegingsgegevens.NET 10 in het vak Framework, selecteer Microsoft.Testing.Platform voor de Test runner en kies Create.
Voer aanvullende informatie in voor het MSTest-testproject
Visual Studio het project maakt en het klassebestand opent in het codevenster met de volgende code. Als de taal die u wilt gebruiken niet wordt weergegeven, wijzigt u de taalkiezer boven aan de pagina.
```
namespace StringLibraryTest
{

    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestMethod1()
        {
        }
    }
}
```
```
Imports Microsoft.VisualStudio.TestTools.UnitTesting

Namespace StringLibraryTest
    <TestClass>
    Public Class Test1
        <TestMethod>
        Sub TestSub()

        End Sub
    End Class
End Namespace
```
De broncode die door de eenheidstestsjabloon is gemaakt, doet het volgende:
- Bevat Microsoft.VisualStudio.TestTools.UnitTesting in het projectbestand StringLibraryTest in C# en importeert Microsoft.VisualStudio.TestTools.UnitTesting in Visual Basic.
- Het kenmerk wordt toegepast op de klasse.
- Hiermee past u het kenmerk TestMethodAttribute toe om TestMethod1 te definiëren in C# of TestSub in Visual Basic.
Elke methode die is getagd met [TestMethod] in een testklasse die is getagd met [TestClass] wordt automatisch uitgevoerd wanneer de eenheidstest wordt uitgevoerd.

Visual Studio Code starten.
Open de ClassLibraryProjects-oplossing die u hebt gemaakt in Maak een .NET-klassebibliotheek.
Selecteer in Solution ExplorerNieuw project of selecteer in het opdrachtenpalet .NET: Nieuw project.
Selecteer MSTest Test Project, geef het de naam StringLibraryTest, selecteer de standaardmap en selecteer Project maken.

De projectsjabloon maakt StringLibraryTest/Test1.cs met de volgende code:
```
namespace StringLibraryTest;

[TestClass]
public class Test1
{
    [TestMethod]
    public void TestMethod1()
    {
    }
}
```
De broncode die door de eenheidstestsjabloon is gemaakt, doet het volgende:
- Het kenmerk wordt toegepast op de klasse.
- Het kenmerk wordt toegepast om te definiëren .
- Hiermee importeert u de naamruimte, die de typen bevat die worden gebruikt voor eenheidstests. De naamruimte wordt geïmporteerd via een instructie in GlobalUsings.cs.
Elke methode die is getagd met [TestMethod] in een testklasse die is getagd met [TestClass] wordt automatisch uitgevoerd wanneer de eenheidstest wordt aangeroepen.

Open de terminal en navigeer naar de map zelfstudies met de projecten StringLibrary en ShowCase.
Maak een nieuw MSTest-testproject:
```
dotnet new mstest -n StringLibraryTest
```
De projectsjabloon maakt StringLibraryTest/Test1.cs met de volgende code:
```
namespace StringLibraryTest;

[TestClass]
public class Test1
{
    [TestMethod]
    public void TestMethod1()
    {
    }
}
```
De broncode die door de eenheidstestsjabloon is gemaakt, doet het volgende:
- Het kenmerk wordt toegepast op de klasse.
- Het kenmerk wordt toegepast om te definiëren .
- Hiermee importeert u de naamruimte, die de typen bevat die worden gebruikt voor eenheidstests.
Elke methode die is getagd met [TestMethod] in een testklasse die is getagd met [TestClass] wordt automatisch uitgevoerd wanneer de eenheidstest wordt aangeroepen.

Een projectreferentie toevoegen

Voeg een verwijzing in het project toe aan het project om het testproject te laten werken met de klasse.

Klik in Solution Explorer met de rechtermuisknop op het knooppunt Afhankelijkheden van het knooppunt StringLibraryTest en selecteer Toevoegingsprojectverwijzing in het contextmenu.
Selecteer in het dialoogvenster Reference Manager het vak naast StringLibrary.

Voeg StringLibrary toe als projectreferentie voor StringLibraryTest.
Kies OK.

Klik in Solution Explorer met de rechtermuisknop op het project StringLibraryTest en selecteer Toevoeging van project.
Selecteer StringLibrary.

Navigeer naar de map StringLibraryTest en voeg de projectverwijzing toe:

cd StringLibraryTest
dotnet add reference ../StringLibrary/StringLibrary.csproj

Testmethoden voor eenheden toevoegen en uitvoeren

Wanneer een eenheidstest wordt uitgevoerd, wordt elke methode die is gemarkeerd met het kenmerk in een klasse die is gemarkeerd met het kenmerk, automatisch uitgevoerd. Een testmethode eindigt wanneer de eerste fout wordt gevonden of wanneer alle tests in de methode slagen.

De meest voorkomende tests roepen leden van de -klasse aan. Veel assertiemethoden bevatten ten minste twee parameters, waarvan een het verwachte testresultaat is en waarvan het werkelijke testresultaat is. Enkele van de meest gebruikte methoden van de -klasse worden weergegeven in de volgende tabel:

Assert-methoden	Function
`Assert.AreEqual`	Controleert of twee waarden of objecten gelijk zijn. De assert mislukt als de waarden of objecten niet gelijk zijn.
`Assert.AreSame`	Controleert of twee objectvariabelen naar hetzelfde object verwijzen. De assert mislukt als de variabelen verwijzen naar verschillende objecten.
`Assert.IsFalse`	Controleert of aan de voorwaarde is voldaan. De assert mislukt als de voorwaarde is.
`Assert.IsNotNull`	Controleert of een object niet is. De assertie faalt als het object is.

U kunt de methode ook gebruiken in een testmethode om aan te geven welk type uitzondering wordt verwacht te genereren. De test mislukt als de opgegeven uitzondering niet wordt opgeworpen.

Bij het testen van de methode wilt u een aantal tekenreeksen opgeven die beginnen met een hoofdletter. U verwacht dat de methode in deze gevallen retourneert, zodat u de methode kunt aanroepen. Op dezelfde manier wilt u een aantal tekenreeksen opgeven die beginnen met iets anders dan een hoofdletter. U verwacht dat de methode in deze gevallen retourneert, zodat u de methode kunt aanroepen.

Omdat uw bibliotheekmethode tekenreeksen verwerkt, wilt u er ook voor zorgen dat zowel een lege tekenreeks () als elke andere tekenreeks succesvol wordt behandeld. Een lege tekenreeks is een tekenreeks die geen tekens heeft en waarvan de tekenreeks 0 is. Een string is er een die niet is geïnitialiseerd. U kunt rechtstreeks aanroepen als een statische methode en één argument doorgeven. U kunt ook aanroepen als een extensiemethode voor een variabele die is toegewezen aan .

U definieert drie methoden, die elk een methode aanroepen voor elk element in een tekenreeksmatrix. U roept een overbelasting van de methode aan waarmee u een foutbericht kunt opgeven dat moet worden weergegeven in het geval van een testfout. Het bericht identificeert de tekenreeks die de fout heeft veroorzaakt.

De testmethoden maken:

Vervang de code in het venster Test1.cs of Test1.vb code door de volgende code:

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports UtilityLibraries

Namespace StringLibraryTest
    <TestClass>
    Public Class UnitTest1
        <TestMethod>
        Public Sub TestStartsWithUpper()
            ' Tests that we expect to return true.
            Dim words() As String = {"Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"}
            For Each word In words
                Dim result As Boolean = word.StartsWithUpper()
                Assert.IsTrue(result,
                       $"Expected for '{word}': true; Actual: {result}")
            Next
        End Sub

        <TestMethod>
        Public Sub TestDoesNotStartWithUpper()
            ' Tests that we expect to return false.
            Dim words() As String = {"alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                               "1234", ".", ";", " "}
            For Each word In words
                Dim result As Boolean = word.StartsWithUpper()
                Assert.IsFalse(result,
                       $"Expected for '{word}': false; Actual: {result}")
            Next
        End Sub

        <TestMethod>
        Public Sub DirectCallWithNullOrEmpty()
            ' Tests that we expect to return false.
            Dim words() As String = {String.Empty, Nothing}
            For Each word In words
                Dim result As Boolean = StringLibrary.StartsWithUpper(word)
                Assert.IsFalse(result,
                       $"Expected for '{If(word Is Nothing, "<null>", word)}': false; Actual: {result}")
            Next
        End Sub
    End Class
End Namespace

De test van hoofdletters in de methode omvat de Griekse hoofdletter alfa (U+0391) en de Cyrillische hoofdletter EM (U+041C). De test van kleine letters in de methode bevat de Griekse kleine letter alfa (U+03B1) en de Cyrillische kleine letter Ghe (U+0433).

Selecteer in de menubalk de optie Bestandopslaan Test1.cs Als of Bestandopslaan Test1.vb As. Selecteer in het dialoogvenster Bestand opslaan als de pijl naast de knop Opslaan en selecteer Opslaan met codering.
Selecteer in het dialoogvenster Opslaan als de knop Ja om het bestand op te slaan.
Selecteer in het dialoogvenster Geavanceerde opties voor opslaan uit de vervolgkeuzelijst Codering de optie Unicode (UTF-8 met handtekening) - Codepage 65001 en selecteer OK.

Als u de broncode niet opslaat als een UTF8-gecodeerd bestand, kan Visual Studio deze opslaan als een ASCII-bestand. Als dat gebeurt, decodert de runtime de UTF8-tekens buiten het ASCII-bereik niet nauwkeurig en zijn de testresultaten niet juist.
Selecteer in de menubalk TestAlle tests uitvoeren. Als het venster Test Explorer niet wordt geopend, opent u het venster door Test explorerte kiezen. De drie tests worden vermeld in de sectie Geslaagde tests en de sectie Samenvatting rapporteert het resultaat van de testuitvoering.

Test Explorer-venster met geslaagde tests

Open StringLibraryTest/Test1.cs en vervang alle code door de volgende code.

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Sla uw wijzigingen op.

Uw tests bouwen en uitvoeren

Klik in Solution Explorer met de rechtermuisknop op de oplossing en selecteer Build of selecteer in de Command Palette .NET: Build.
Selecteer het testvenster, selecteer Tests uitvoeren of selecteer in het opdrachtenpalet de optie Test: Alle tests uitvoeren.

Open StringLibraryTest/Test1.cs en vervang alle code door de volgende code:

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Sla uw wijzigingen op en voer de tests uit:
```
dotnet test
```
De tests moeten slagen.

Testfouten afhandelen

Als u testgestuurde ontwikkeling (TDD) uitvoert, schrijft u eerst tests en mislukken ze de eerste keer dat u ze uitvoert. Vervolgens voegt u code toe aan de app waarmee de test slaagt. Voor deze zelfstudie hebt u de test gemaakt nadat u de app-code hebt geschreven die door de test wordt gevalideerd, dus u hebt de test nog niet zien falen. Als u wilt controleren of een test mislukt wanneer u verwacht dat deze mislukt, voegt u een ongeldige waarde toe aan de testinvoer.

Wijzig de array in de methode om de tekenreeks "Error" op te nemen.

string[] words = { "alphabet", "Error", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                   "1234", ".", ";", " " };

Dim words() As String = { "alphabet", "Error", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                   "1234", ".", ";", " " }

Voer de test uit door in de menubalk TestAlle tests uitvoeren te selecteren. Het venster Test Explorer geeft aan dat er twee tests zijn geslaagd en één test is mislukt.

Test Explorer-venster met mislukte tests
Selecteer de mislukte test, .

In het venster Test Explorer wordt het bericht weergegeven dat is geproduceerd door de assert: 'Assert.IsFalse is mislukt.' Verwacht voor 'Fout': niet waar; feitelijk: wel waar. Vanwege de storing zijn de tekenreeksen in de array na 'Fout' niet getest.

Test Explorer-venster met de IsFalse-assertiefout

Voer de tests uit door te klikken op de groene fout naast de test in de editor.

De uitvoer laat zien dat de test mislukt en er wordt een foutbericht weergegeven voor de mislukte test: 'Assert.IsFalse is mislukt. Verwacht voor 'Fout': onwaar; werkelijk: waar". Vanwege de fout zijn er geen tekenreeksen in de array getest na "Error".

Voer de tests uit:
```
dotnet test
```
De uitvoer laat zien dat de test mislukt en er wordt een foutbericht weergegeven voor de mislukte test: 'Assert.IsFalse is mislukt. Verwacht voor 'Fout': onwaar; werkelijk: Waar". Vanwege de fout zijn er geen tekenreeksen in de array getest na "Error".

Verwijder de tekst 'Fout' die u hebt toegevoegd.
Voer de test opnieuw uit en de tests zijn geslaagd.

De releaseversie van de bibliotheek testen

Nu alle tests zijn geslaagd bij het uitvoeren van de debug-build van de bibliotheek, voert u de tests nog een keer uit tegen de release-build van de bibliotheek. Een aantal factoren, waaronder compileroptimalisaties, kan soms verschillend gedrag produceren tussen foutopsporing en release-builds.

Ga als volgende te werk om de release-build te testen:

Wijzig in de werkbalk Visual Studio de buildconfiguratie van Debug in Release.
Klik in Solution Explorer met de rechtermuisknop op het project StringLibrary en selecteer Build in het contextmenu om de bibliotheek opnieuw te compileren.
Selecteer in de menubalk TestAlle testen uitvoeren om de unit tests uit te voeren. De tests zijn geslaagd.

Voer de tests uit met de buildconfiguratie van de release:

dotnet test StringLibraryTest/StringLibraryTest.csproj --configuration Release

De tests zijn geslaagd.

Voer de tests uit met de buildconfiguratie van de release:

dotnet test --configuration Release

De tests zijn geslaagd.

Foutopsporingstests

Als u Visual Studio als uw IDE gebruikt, kunt u hetzelfde proces gebruiken dat wordt weergegeven in Tutorial: Fouten opsporen in een .NET-consoletoepassing om fouten in code op te sporen met behulp van uw eenheidstestproject. In plaats van het project ShowCase-app te starten, klikt u met de rechtermuisknop op het project StringLibraryTests en selecteert u Foutopsporingstests in het contextmenu.

Visual Studio het testproject start met het bijgevoegde foutopsporingsprogramma. De uitvoering stopt op een onderbrekingspunt dat u hebt toegevoegd aan het testproject of de onderliggende bibliotheekcode.

Als u Visual Studio Code als uw IDE gebruikt, kunt u hetzelfde proces volgen zoals weergegeven in Debug a .NET console application om code te debuggen met uw unit test project. Open StringLibraryTest/Test1.cs in plaats van het project ShowCase-app te starten en selecteer Debug Tests in het huidige bestand tussen regel 7 en 8. Als u het niet kunt vinden, drukt u op CtrlShiftP om het opdrachtenpalet te openen en het venster Opnieuw laden in te voeren.

Visual Studio Code start het testproject met de debugger gekoppeld. De uitvoering stopt op elk onderbrekingspunt dat u hebt toegevoegd aan het testproject of de onderliggende bibliotheekcode.

Aanvullende bronnen

Eenheid testen in .NET

Middelen opschonen

GitHub uw Codespace automatisch verwijdert na 30 dagen inactiviteit. Als u van plan bent om meer tutorials uit deze serie te volgen, kunt u uw Codespace geconfigureerd laten. Als u klaar bent om de .NET-site te bezoeken om de .NET SDK te downloaden, kunt u uw Codespace verwijderen. Als u uw Codespace wilt verwijderen, opent u een browservenster en gaat u naar uw Codespaces. U ziet een lijst met uw codespaces in het venster. Selecteer de drie puntjes () in de vermelding voor de zelfstudiecoderuimte. Selecteer vervolgens Verwijderen.

Volgende stappen

In deze zelfstudie hebt u een klassebibliotheek getest. U kunt de bibliotheek beschikbaar maken voor anderen door deze als pakket te publiceren naar NuGet . Volg een NuGet-zelfstudie voor meer informatie:

Een pakket maken en publiceren met behulp van de dotnet CLI

Als u een bibliotheek publiceert als een NuGet-pakket, kunnen anderen deze installeren en gebruiken. Volg een NuGet-zelfstudie voor meer informatie:

Een pakket installeren en gebruiken met de dotnet CLI

Een bibliotheek hoeft niet als pakket te worden gedistribueerd. Het kan worden gebundeld met een console-app die deze gebruikt. Zie de eerdere zelfstudie in deze reeks voor meer informatie over het publiceren van een console-app:

Publiceer een .NET-consoletoepassing

Feedback

Is deze pagina nuttig?

Last updated on 2026-03-06