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 zelfstudie werkt met de oplossing die u maakt in Maak een .NET klassebibliotheek.

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.
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.
- TestClassAttribute Het kenmerk wordt toegepast op de Test1 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.

Start Visual Studio Code.
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 attribuut TestClassAttribute wordt toegepast op de klasse Test1.
- Het kenmerk TestMethodAttribute wordt toegepast om TestMethod1 te definiëren.
- Hiermee importeert u de Microsoft.VisualStudio.TestTools.UnitTesting naamruimte, die de typen bevat die worden gebruikt voor eenheidstests. De naamruimte wordt geïmporteerd via een global using 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 TestClassAttribute wordt toegepast op de klasse Test1.
- Het attribuut TestMethodAttribute wordt toegepast om TestMethod1 te definiëren.
- Hiermee importeert u de Microsoft.VisualStudio.TestTools.UnitTesting 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 naar het StringLibrary project toe in het StringLibraryTest project, zodat het testproject kan werken met de StringLibrary 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.
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 TestMethodAttribute kenmerk in een klasse die is gemarkeerd met het TestClassAttribute 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 Assert-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 Assert-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 `false`is voldaan. De assert mislukt als de voorwaarde `true`is.
`Assert.IsNotNull`	Controleert of een object niet `null`is. De assertie faalt als het object `null`is.

U kunt de Assert.Throws 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 StringLibrary.StartsWithUpper methode wilt u een aantal tekenreeksen opgeven die beginnen met een hoofdletter. U verwacht dat de methode in deze gevallen true retourneert, zodat u de Assert.IsTrue 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 false retourneert, zodat u de Assert.IsFalse methode kunt aanroepen.

Omdat uw bibliotheekmethode tekenreeksen verwerkt, wilt u er ook voor zorgen dat deze een lege tekenreeks (String.Empty) en een null-tekenreeks correct verwerkt. Een lege tekenreeks is een tekenreeks die geen tekens heeft en waarvan Length de tekenreeks 0 is. Een null tekenreeks is een tekenreeks die niet is geïnitialiseerd. U kunt rechtstreeks aanroepen StartsWithUpper als een statische methode en één String argument doorgeven. U kunt ook aanroepen StartsWithUpper als een extensiemethode voor een string variabele die is toegewezen aan null.

U definieert drie methoden, die elk een Assert 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 TestStartsWithUpper methode omvat de Griekse hoofdletter alfa (U+0391) en de Cyrillische hoofdletter EM (U+041C). De test van kleine letters in de methode TestDoesNotStartWithUpper bevat de Griekse kleine letter alfa (U+03B1) en de Cyrillische kleine letter Ghe (U+0433).

Selecteer in de menubalk de optie Bestand>opslaan Test1.cs Als of Bestand>opslaan 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 Test>Alle 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.

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 vanuit het 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 words array in de TestDoesNotStartWithUpper 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 Test>Alle tests uitvoeren te selecteren. Het venster Test Explorer geeft aan dat er twee tests zijn geslaagd en één test is mislukt.
Selecteer de mislukte test, TestDoesNotStartWith.

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.

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 Test>Alle 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 gebruikt als uw IDE, kunt u hetzelfde proces gebruiken dat wordt weergegeven in Debug a .NET console application om code te debuggen met behulp van uw unittestproject. 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 Ctrl+Shift+P om het opdrachtenpalet te openen en het venster Opnieuw laden in te voeren.

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

Aanvullende bronnen

basisbeginselen van Unit-test - Visual Studio
Eenheid testen in .NET

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-11