Kom igång med liveenhetstestning

Artikel
01/06/2025

När du aktiverar liveenhetstestning i en Visual Studio-lösning visar den visuellt testtäckningen och statusen för dina tester. Live Unit Testing kör också tester dynamiskt när du ändrar koden och meddelar dig omedelbart när ändringarna gör att testerna misslyckas.

Direktenhetstestning kan användas för att testa lösningar som är avsedda för .NET Framework, .NET Core eller .NET 5+. I den här självstudien lär du dig att använda liveenhetstestning genom att skapa ett enkelt klassbibliotek som riktar sig till .NET, och du skapar ett MSTest-projekt som riktar sig till .NET för att testa det.

Den fullständiga C#-lösningen kan laddas ned från MicrosoftDocs/visualstudio-docs lagringsplats på GitHub.

Förutsättningar

Den här handledningen kräver att du har installerat utgåvan Visual Studio Enterprise med arbetsbelastningen .NET-skrivbordsutveckling.

Skapa lösningen och klassbiblioteksprojektet

Börja med att skapa en Visual Studio-lösning med namnet UtilityLibraries som består av ett enda .NET-klassbiblioteksprojekt, StringLibrary.

Lösningen är bara en container för ett eller flera projekt. Om du vill skapa en tom lösning öppnar du Visual Studio och gör följande:

Välj File>New>Project från toppnivåmenyn i Visual Studio.
Skriv lösning i mallsökningsrutan och välj sedan mallen Tom lösning. Ge projektet namnet UtilityLibraries.
Slutför skapandet av lösningen.

Nu när du har skapat lösningen skapar du ett klassbibliotek med namnet StringLibrary som innehåller ett antal tilläggsmetoder för att arbeta med strängar.

I Solution Explorerhögerklickar du på lösningen UtilityLibraries och väljer Lägg till>Nytt projekt.
Skriv klassbiblioteket i mallsökningsrutan och välj mallen klassbibliotek som är avsedd för .NET eller .NET Standard. Klicka på Nästa.
Ge projektet namnet StringLibrary.
Klicka på Skapa för att skapa projektet.

Ersätt all befintlig kod i kodredigeraren med följande kod:

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 har tre statiska metoder:

StartsWithUpper returnerar true om en sträng börjar med ett versaler. annars returneras false.
StartsWithLower returnerar true om en sträng börjar med en gemen; annars returnerar false.
HasEmbeddedSpaces returnerar true om en sträng innehåller ett inbäddat blankstegstecken. annars returneras false.

Välj Skapa>Bygg lösning från huvudmenyn i Visual Studio. Bygget bör lyckas.

Skapa testprojektet

Nästa steg är att skapa enhetstestprojektet för att testa StringLibrary-biblioteket. Skapa enhetstesterna genom att utföra följande steg:

I Solution Explorerhögerklickar du på lösningen UtilityLibraries och väljer Lägg till>Nytt projekt.
Skriv enhetstest i mallsökningsrutan, välj C# som språk och välj sedan MSTest Unit Test Project för .NET-mallen. Klicka på Nästa.

Notera

I Visual Studio 2019 version 16.9 är namnet på MSTest-projektmallen Unit Test Project.
Ge projektet namnet StringLibraryTests och klicka på Nästa.
Välj antingen det rekommenderade målramverket eller .NET 8 och välj sedan Skapa.

Obs

Den här självstudien om att komma igång använder liveenhetstestning med MSTest-testramverket. Du kan också använda xUnit- och NUnit-testramverken.
Enhetstestprojektet kan inte automatiskt komma åt klassbiblioteket som det testar. Du ger testbiblioteket åtkomst genom att lägga till en referens till klassbiblioteksprojektet. Det gör du genom att högerklicka på projektet StringLibraryTests och välja Lägg till>projektreferens. I dialogrutan Reference Manager kontrollerar du att fliken Solution är markerad och väljer StringLibrary-projektet enligt följande bild.

Ersätt testkoden för boilerplate-enheten som tillhandahålls av mallen med följande kod:

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

Spara projektet genom att välja ikonen Spara i verktygsfältet.

Eftersom enhetstestkoden innehåller vissa icke-ASCII-tecken visas följande dialogruta för att varna om att vissa tecken går förlorade om du sparar filen i ascii-standardformatet.
Välj knappen Spara med annan kodning.
I listrutan Kodning i dialogrutan Fortsätt spara alternativ väljer du Unicode (UTF-8 utan signatur) – Kodsida 65001, som följande bild visar:
Kompilera enhetstestprojektet genom att välja Skapa>Återskapa lösning från Visual Studio-menyn på den översta nivån.

Du har skapat ett klassbibliotek och några enhetstester för det. Nu har du slutfört de förberedelser som behövs för att använda Live Unit Testing.

Aktivera Live-enhetstester

Hittills, även om du har skrivit testerna för StringLibrary-klassbiblioteket, har du inte kört dem. Live-enhetstestning kör dem automatiskt när du aktiverar det. För att göra det, gör följande:

Du kan också välja det kodredigeringsfönster som innehåller koden för StringLibrary. Det här är antingen Class1.cs för ett C#-projekt eller Class1.vb för ett Visual Basic-projekt. (Med det här steget kan du visuellt granska resultatet av dina tester och omfattningen av din kodtäckning när du aktiverar liveenhetstestning.)
Välj Test>Live Unit Testing>Start på visual studio-menyn på den översta nivån.
Kontrollera konfigurationen för liveenhetstestning genom att se till att lagringsplatsens rot innehåller sökvägen till källfilerna för både verktygsprojektet och testprojektet. Välj Nästa och sedan Slutför.

I fönstret Liveenhetstestning väljer du länken ta med alla tester (du kan också välja ikonen för knappen Playlist, sedan StringLibraryTest, vilket väljer alla tester under den. Avmarkera sedan knappen Playlist för att avsluta läget för redigering.)
Visual Studio återskapar projektet och startar Live Unit Test, som automatiskt kör alla dina tester.

Visual Studio återskapar projektet och startar Live Unit Test, som automatiskt kör alla dina tester.

När testerna har körts visar liveenhetstestning både de övergripande resultaten och resultatet av enskilda tester. Dessutom visar kodredigerarens fönster grafiskt både testkodens täckning och resultatet för dina tester. Som följande bild visar har alla tre testerna körts korrekt. Det visar också att våra tester har täckt alla kodsökvägar i metoden StartsWithUpper och att alla dessa tester har körts framgångsrikt (vilket indikeras av den gröna bocken, "✓"). Slutligen visar den att ingen av de andra metoderna i StringLibrary har kodtäckning (vilket indikeras av en blå linje, "➖").

fönstret Live Test Explorer och kodredigeraren när du har startat liveenhetstestning

Live Test Explorer-fönstret och kodredigeringsfönstret efter att ha startat Live enhetstestning

Du kan också få mer detaljerad information om testtäckning och testresultat genom att välja en viss kodtäckningsikon i kodredigerarens fönster. Gör följande för att undersöka den här informationen:

Klicka på den gröna bockmarkeringen på raden som läser if (String.IsNullOrWhiteSpace(s)) i metoden StartsWithUpper. Som följande bild visar visar liveenhetstestning att tre tester täcker den kodraden och att alla har körts korrekt.
Klicka på den gröna bockmarkeringen på raden som läser return Char.IsUpper(s[0]) i metoden StartsWithUpper. Som följande bild visar visar liveenhetstestning att endast två tester täcker den kodraden och att alla har körts korrekt.

Det största problemet som liveenhetstestning identifierar är ofullständig kodtäckning. Du tar upp det i nästa avsnitt.

Utöka testtäckningen

I det här avsnittet utökar du enhetstesterna till metoden StartsWithLower. När du gör det fortsätter Live Unit Testing dynamiskt att testa koden.

Om du vill utöka kodtäckningen till metoden StartsWithLower gör du följande:

Lägg till följande TestStartsWithLower- och TestDoesNotStartWithLower-metoder i projektets källkodsfil för test:

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

Ändra metoden DirectCallWithNullOrEmpty genom att lägga till följande kod direkt efter anropet till metoden 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 kör automatiskt nya och ändrade tester när du ändrar källkoden. Som följande bild visar har alla tester, inklusive de två som du har lagt till och den som du har ändrat, lyckats.
Växla till fönstret som innehåller källkoden för klassen StringLibrary. Live-enhetstester visar nu att vår kodtäckning har utökats till metoden StartsWithLower.

I vissa fall kan lyckade tester i Test Explorer vara nedtonade. Det indikerar att ett test körs för närvarande eller att testet inte har körts igen eftersom det inte har gjorts några kodändringar som skulle påverka testet sedan det senast kördes.

Hittills har alla våra tester lyckats. I nästa avsnitt ska vi undersöka hur du kan hantera testfel.

Hantera ett testfel

I det här avsnittet ska du utforska hur du kan använda liveenhetstestning för att identifiera, felsöka och åtgärda testfel. Det gör du genom att utöka testtäckningen till metoden HasEmbeddedSpaces.

Lägg till följande metod i testfilen:

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

När testet körs indikerar liveenhetstestning att TestHasEmbeddedSpaces-metoden har misslyckats, som följande bild visar:
Välj det fönster som visar bibliotekskoden. Live Unit Testing har utökat kodtäckningen till metoden HasEmbeddedSpaces. Den rapporterar också testfelet genom att lägga till en röd "🞩" till rader som omfattas av misslyckade tester.
Hovra över raden med metodsignaturen HasEmbeddedSpaces. Live-enhetstestning visar ett verktygstips som rapporterar att metoden omfattas av ett test, som visas i följande illustration.
Välj det misslyckade TestHasEmbeddedSpaces testet. Live-enhetstestning ger dig några alternativ, till exempel att köra alla tester och felsöka alla tester, som följande bild visar:
Välj Felsök alla för att felsöka det misslyckade testet.
Visual Studio kör testet i felsökningsläge.

Testet tilldelar varje sträng i en matris till en variabel med namnet phrase och skickar den till metoden HasEmbeddedSpaces. Programkörningen pausar och anropar felsökningsprogrammet första gången kontrolluttrycket är false. Undantagsdialogrutan som är resultatet av det oväntade värdet i Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue-metodanropet visas i följande bild.

undantagsdialogrutan

Dessutom är alla felsökningsverktyg som Visual Studio tillhandahåller tillgängliga för att hjälpa oss att felsöka vårt misslyckade test, som följande bild visar:

Observera i fönstret Autos att värdet för variabeln phrase är "Name\tDescription", som är det andra elementet i matrisen. Testmetoden förväntar sig att HasEmbeddedSpaces returnerar true när den får den här strängen; i stället returnerar den false. Uppenbarligen känner den inte igen "\t", fliktecknet, som ett inbäddat utrymme.
Välj Felsök>Fortsätt, tryck på F5eller klicka på knappen Fortsätt i verktygsfältet för att fortsätta köra testprogrammet. Eftersom ett ohanterat undantag inträffade avslutas testet. Detta ger tillräckligt med information för en förundersökning av felet. Antingen gjorde TestHasEmbeddedSpaces (testrutinen) ett felaktigt antagande eller så känner HasEmbeddedSpaces inte igen alla inbäddade blanksteg korrekt.
Om du vill diagnostisera och åtgärda problemet börjar du med metoden StringLibrary.HasEmbeddedSpaces. Titta på jämförelsen i metoden HasEmbeddedSpaces. Det anser att ett inbäddat utrymme är U+0020. Unicode Standard innehåller dock ett antal andra blankstegstecken. Detta tyder på att bibliotekskoden har testats felaktigt för ett blankstegstecken.
Ersätt likhetsjämförelsen med ett anrop till metoden System.Char.IsWhiteSpace:
```
if (Char.IsWhiteSpace(ch))
```
Live Unit Testing kör automatiskt den misslyckade testmetoden igen.

Live Unit Testing visar de uppdaterade resultaten, som också visas i kodredigeringsfönstret.