Aan de slag met Live Unit Testing

Artikel
01/27/2025

Wanneer u Live Unit Testing inschakelt in een Visual Studio-oplossing, wordt uw testdekking en de status van uw tests visueel weergegeven. Live Unit Testing voert ook dynamisch tests uit wanneer u uw code wijzigt en u onmiddellijk op de hoogte stelt wanneer uw wijzigingen ertoe leiden dat tests mislukken.

Live Unit Testing kan worden gebruikt om oplossingen te testen die gericht zijn op .NET Framework, .NET Core of .NET 5+. In deze zelfstudie leert u hoe u Live Unit Testing kunt gebruiken door een eenvoudige klassebibliotheek te maken die is gericht op .NET en u maakt een MSTest-project dat is gericht op .NET om het te testen.

De volledige C#-oplossing kan worden gedownload uit de MicrosoftDocs/visualstudio-docs opslagplaats op GitHub.

Voorwaarden

Voor deze zelfstudie moet u Visual Studio Enterprise Edition hebben geïnstalleerd met de .NET-desktopontwikkeling workload.

De oplossing en het klassebibliotheekproject maken

Maak eerst een Visual Studio-oplossing met de naam UtilityLibraries die bestaat uit één .NET-klassebibliotheekproject, StringLibrary.

De oplossing is slechts een container voor een of meer projecten. Als u een lege oplossing wilt maken, opent u Visual Studio en doet u het volgende:

Selecteer File>New>Project in het Visual Studio-menu bovenin.
Typ oplossing in het zoekvak voor sjablonen en selecteer vervolgens de sjabloon Lege oplossing. Geef het project de naam UtilityLibraries.
Voltooi het maken van de oplossing.

Nu u de oplossing hebt gemaakt, maakt u een klassebibliotheek met de naam StringLibrary die een aantal extensiemethoden bevat voor het werken met tekenreeksen.

Klik in Solution Explorermet de rechtermuisknop op de oplossing UtilityLibraries en selecteer Add>New Project.
Typ klassebibliotheek in het zoekvak voor sjablonen en selecteer de sjabloon klassebibliotheek die gericht is op .NET of .NET Standard. Klik op Volgende.
Geef het project de naam StringLibrary.
Klik op Maak om het project aan te maken.

Vervang alle bestaande code in de code-editor door de volgende code:

using System;

namespace UtilityLibraries
{
    public static class StringLibrary
    {
        public static bool StartsWithUpper(this string s)
        {
            if (String.IsNullOrWhiteSpace(s))
                return false;

            return Char.IsUpper(s[0]);
        }

        public static bool StartsWithLower(this string s)
        {
            if (String.IsNullOrWhiteSpace(s))
                return false;

            return Char.IsLower(s[0]);
        }

        public static bool HasEmbeddedSpaces(this string s)
        {
            foreach (var ch in s.Trim())
            {
                if (ch == ' ')
                    return true;
            }
            return false;
        }
    }
}

StringLibrary heeft drie statische methoden:

StartsWithUpper retourneert true als een tekenreeks begint met een hoofdletter; anders wordt falsegeretourneerd.
StartsWithLower retourneert true als een tekenreeks begint met een kleine letter; anders wordt falsegeretourneerd.
HasEmbeddedSpaces retourneert true als een tekenreeks een ingesloten witruimteteken bevat; anders wordt falsegeretourneerd.

Selecteer Build>Build Solution in het menu van Visual Studio op het hoogste niveau. De build moet slagen.

Het testproject maken

De volgende stap is het maken van het eenheidstestproject om de StringLibrary-bibliotheek te testen. Maak de eenheidstests door de volgende stappen uit te voeren:

Klik in Solution Explorermet de rechtermuisknop op de oplossing UtilityLibraries en selecteer Add>New Project.
Typ eenheidstest in het zoekvak voor sjablonen, selecteer C# als taal en selecteer vervolgens het MSTest Unit Test Project voor .NET-sjabloon. Klik op Volgende.

Notitie

In Visual Studio 2019 versie 16.9 is de naam van de MSTest-projectsjabloon Moduletestproject.
Noem het project StringLibraryTests en klik op Volgende.
Kies het aanbevolen doelframework of .NET 8 en selecteer vervolgens Aanmaken.

Notitie

In deze beginhandleiding wordt gebruikgemaakt van Live Unit Testing met het MSTest testframework. U kunt ook de xUnit- en NUnit-testframeworks gebruiken.
Het eenheidstestproject heeft geen automatisch toegang tot de klassebibliotheek die wordt getest. U geeft de testbibliotheek toegang door een verwijzing naar het klassebibliotheekproject toe te voegen. Klik hiervoor met de rechtermuisknop op het StringLibraryTests project en selecteer >Projectverwijzing toevoegen. Controleer in het dialoogvenster Reference Manager of het tabblad Solution is geselecteerd en selecteer het StringLibrary-project, zoals wordt weergegeven in de volgende afbeelding.

Vervang de standaardeenheidtestcode die door de sjabloon wordt geleverd door de volgende code:

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public class UnitTest1
    {
        [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 ? "<null>" : word)}': " +
                               $"false; Actual: {result}");
            }
        }
    }
}

Sla uw project op door het pictogram Opslaan op de werkbalk te selecteren.

Omdat de eenheidstestcode enkele niet-ASCII-tekens bevat, ziet u het volgende dialoogvenster om te waarschuwen dat sommige tekens verloren gaan als u het bestand opslaat in de standaard-ASCII-indeling.
Kies de knop Opslaan met andere codering.
Kies in de vervolgkeuzelijst Encoding van het dialoogvenster Geavanceerde opties voor opslaan, Unicode (UTF-8 zonder handtekening) - Codepage 65001, zoals in de volgende afbeelding wordt weergegeven.
Compileer het eenheidstestproject door Build>Rebuild Solution te selecteren in het menu van Visual Studio op het hoogste niveau.

U hebt een klassebibliotheek en enkele eenheidstests voor deze bibliotheek gemaakt. U hebt nu de voorbereidingslijsten voltooid die nodig zijn voor het gebruik van Live Unit Testing.

Live unit testen inschakelen

Tot nu toe hebt u de tests voor de StringLibrary-klassebibliotheek geschreven, maar u hebt ze nog niet uitgevoerd. Live Unit Testing voert deze automatisch uit zodra u deze inschakelt. Ga hiervoor als volgt te werk:

Selecteer eventueel het venster van de code-editor dat de code voor StringLibrary bevat. Dit is Class1.cs voor een C#-project of Class1.vb voor een Visual Basic-project. (Met deze stap kunt u het resultaat van uw tests en de omvang van uw codedekking visueel inspecteren zodra u Live Unit Testing hebt ingeschakeld.)
Selecteer Test>Live Unit Testing>Start in het menu van Visual Studio op het hoogste niveau.
Controleer de configuratie voor Live Unit Testing door ervoor te zorgen dat de hoofdmap van de opslagplaats het pad naar de bronbestanden voor zowel het hulpprogrammaproject als het testproject bevat. Selecteer Volgende en voltooien.

Selecteer in het venster Live Unit Testing de koppeling neem alle tests op (Als alternatief kunt u het pictogram van de knop Afspeellijst selecteren en vervolgens de StringLibraryTest, waardoor alle tests eronder worden geselecteerd. Deselecteer daarna de knop Afspeellijst om de bewerkingsmodus te verlaten.)
Visual Studio bouwt het project opnieuw op en start Live Unit Test, waarmee al uw tests automatisch worden uitgevoerd.

Visual Studio bouwt het project opnieuw op en start Live Unit Test, waarmee al uw tests automatisch worden uitgevoerd.

Wanneer het uitvoeren van uw tests is voltooid, Live Unit Testing zowel de algehele resultaten als het resultaat van afzonderlijke tests weergeeft. Daarnaast worden in het venster van de code-editor zowel de dekking van uw testcode als het resultaat voor uw tests grafisch weergegeven. Zoals in de volgende afbeelding wordt weergegeven, zijn alle drie de tests uitgevoerd. Het toont ook aan dat onze tests alle codepaden in de StartsWithUpper-methode hebben behandeld en dat deze tests allemaal zijn uitgevoerd (wat wordt aangegeven met het groene vinkje "✓"). Ten slotte ziet u dat geen van de andere methoden in StringLibrary codedekking heeft (die wordt aangegeven met een blauwe lijn, "➖").

Het venster van Live Test Explorer en de code-editor na het starten van Live Unit Testing

Het venster Live Test Explorer en code-editor na het starten van live-eenheid testen

U kunt ook gedetailleerdere informatie krijgen over testdekking en testresultaten door een bepaald pictogram voor codedekking te selecteren in het venster van de code-editor. Ga als volgt te werk om dit detail te bekijken:

Klik op het groene vinkje op de regel waarop if (String.IsNullOrWhiteSpace(s)) staat in de methode StartsWithUpper. Zoals in de volgende afbeelding wordt weergegeven, geeft Live Unit Testing aan dat drie tests betrekking hebben op die coderegel en dat allemaal zijn uitgevoerd.
Klik op het groene vinkje op de regel die return Char.IsUpper(s[0]) vermeldt in de methode StartsWithUpper. Zoals in de volgende afbeelding wordt weergegeven, geeft Live Unit Testing aan dat slechts twee tests betrekking hebben op die coderegel en dat allemaal zijn uitgevoerd.

Het belangrijkste probleem dat Live Unit Testing identificeren, is onvolledige code coverage. Je zult het in de volgende paragraaf behandelen.

Testdekking uitbreiden

In deze sectie gaat u uw eenheidstests uitbreiden naar de methode StartsWithLower. Terwijl u dat doet, blijft Live Unit Testing uw code dynamisch testen.

Ga als volgt te werk om de codedekking uit te breiden naar de methode StartsWithLower:

Voeg de volgende TestStartsWithLower en TestDoesNotStartWithLower methoden toe aan het broncodebestand van uw project:

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

[TestMethod]
public void TestDoesNotStartWithLower()
{
    // Tests that we expect to return false.
    string[] words = { "Alphabet", "Zebra", "ABC", "Αθήνα", "Москва",
                       "1234", ".", ";", " "};
    foreach (var word in words)
    {
        bool result = word.StartsWithLower();
        Assert.IsFalse(result,
                       $"Expected for '{word}': false; Actual: {result}");
    }
}

Wijzig de methode DirectCallWithNullOrEmpty door de volgende code toe te voegen direct na de aanroep van de methode Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse.

// Code to add to UnitTest1.cs
result = StringLibrary.StartsWithLower(word);
Assert.IsFalse(result,
               $"Expected for '{(word == null ? "<null>" : word)}': " +
               $"false; Actual: {result}");

Live Unit Testing voert automatisch nieuwe en gewijzigde tests uit wanneer u de broncode wijzigt. Zoals in de volgende afbeelding wordt weergegeven, zijn alle tests, inclusief de twee die u hebt toegevoegd en degene die u hebt gewijzigd, geslaagd.
Schakel over naar het venster met de broncode voor de klasse StringLibrary. Live Unit Testing laat nu zien dat onze codedekking wordt uitgebreid naar de StartsWithLower methode.

In sommige gevallen zijn geslaagde tests in Test Explorer- mogelijk grijs weergegeven. Dit geeft aan dat er momenteel een test wordt uitgevoerd of dat de test niet opnieuw is uitgevoerd, omdat er geen codewijzigingen zijn aangebracht die van invloed zijn op de test sinds deze voor het laatst is uitgevoerd.

Tot nu toe zijn al onze tests geslaagd. In de volgende sectie bekijken we hoe u testfouten kunt afhandelen.

Een testfout afhandelen

In deze sectie leert u hoe u Live Unit Testing kunt gebruiken om testfouten te identificeren, op te lossen en aan te pakken. U doet dit door de testdekking uit te breiden naar de HasEmbeddedSpaces methode.

Voeg de volgende methode toe aan uw testbestand:

[TestMethod]
public void TestHasEmbeddedSpaces()
{
    // Tests that we expect to return true.
    string[] phrases = { "one car", "Name\u0009Description",
                         "Line1\nLine2", "Line3\u000ALine4",
                         "Line5\u000BLine6", "Line7\u000CLine8",
                         "Line0009\u000DLine10", "word1\u00A0word2" };
    foreach (var phrase in phrases)
    {
        bool result = phrase.HasEmbeddedSpaces();
        Assert.IsTrue(result,
                      $"Expected for '{phrase}': true; Actual: {result}");
    }
}

Wanneer de test wordt uitgevoerd, geeft Live Unit Testing aan dat de TestHasEmbeddedSpaces-methode is mislukt, zoals in de volgende afbeelding wordt weergegeven:
Selecteer het venster waarin de bibliotheekcode wordt weergegeven. Live Unit Testing heeft de codedekking uitgebreid naar de methode HasEmbeddedSpaces. Ook wordt de testfout gerapporteerd door een rode "🞩" toe te voegen aan regels die worden gedekt door mislukte tests.
Beweeg de muisaanwijzer over de lijn met de HasEmbeddedSpaces methodesignatuur. Live Unit Testing toont een tooltip die aangeeft dat de methode door één test wordt gedekt, zoals in de volgende afbeelding te zien is.
Selecteer de mislukte TestHasEmbeddedSpaces-test. Live Unit Testing biedt een aantal opties, zoals het uitvoeren van alle tests en het opsporen van fouten in alle tests, zoals in de volgende afbeelding wordt weergegeven:
Selecteer Debug alles om de mislukte test te debuggen.
Visual Studio voert de test uit in de foutopsporingsmodus.

De test wijst elke tekenreeks in een matrix toe aan een variabele met de naam phrase en geeft deze door aan de HasEmbeddedSpaces methode. De uitvoering van het programma wordt onderbroken en roept het foutopsporingsprogramma aan wanneer de assertexpressie voor het eerst wordt false. Het uitzonderingsdialoogvenster dat het resultaat is van de onverwachte waarde in de Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue methode-aanroep, wordt weergegeven in de volgende afbeelding.

Bovendien zijn alle hulpprogramma's voor foutopsporing die Visual Studio biedt beschikbaar om ons te helpen bij het oplossen van problemen met onze mislukte test, zoals in de volgende afbeelding wordt weergegeven:

hulpprogramma's voor foutopsporing in Visual Studio

hulpprogramma's voor foutopsporing in Visual Studio

Let op in het venster Autos dat de waarde van de variabele phrase 'Name\tDescription' is, het tweede element van de matrix. De testmethode verwacht dat HasEmbeddedSpacestrue retourneert wanneer deze tekenreeks wordt doorgegeven; in plaats daarvan wordt falsegeretourneerd. Het is duidelijk dat '\t', het tabteken, niet wordt herkend als een ingesloten ruimte.
Selecteer Foutopsporing>Doorgaan, druk op F5-of klik op de knop Doorgaan op de werkbalk om door te gaan met het uitvoeren van het testprogramma. Omdat er een niet-verwerkte uitzondering is opgetreden, wordt de test beëindigd. Dit biedt voldoende informatie voor een voorlopig onderzoek naar de bug. TestHasEmbeddedSpaces (de testroutine) heeft een onjuiste aanname gedaan, of HasEmbeddedSpaces herkent niet alle ingesloten ruimten correct.
Als u het probleem wilt vaststellen en corrigeren, begint u met de StringLibrary.HasEmbeddedSpaces methode. Bekijk de vergelijking in de methode HasEmbeddedSpaces. Het beschouwt een ingesloten ruimte als U+0020. De Unicode-standaard bevat echter een aantal andere spatietekens. Dit suggereert dat de bibliotheekcode onjuist is getest op een witruimteteken.
Vervang de gelijkheidsvergelijking door een aanroep naar de methode System.Char.IsWhiteSpace:
```
if (Char.IsWhiteSpace(ch))
```
Live Unit Testing voert de mislukte testmethode automatisch opnieuw uit.

Live Unit Testing toont dat de bijgewerkte resultaten worden weergegeven, die ook worden weergegeven in het venster van de code-editor.