Erste Schritte mit Live Unit Testing

Artikel
12/20/2023

Wenn Sie Live Unit Testing in einer Visual Studio-Projektmappe aktivieren, werden Ihre Testabdeckung und der Status Ihrer Tests dargestellt. Live Unit Testing führt außerdem dynamisch Tests durch, wenn Sie den Code ändern, und Sie werden sofort benachrichtigt, wenn Ihre Änderungen dazu führen, dass Tests nicht erfolgreich sind.

Live Unit Testing kann zum Testen von Projektmappen für .NET Framework, .NET Core oder .NET 5 und höher verwendet werden. In diesem Tutorial erlernen Sie die Verwendung von Live Unit Testing, indem Sie eine einfache Klassenbibliothek für .NET erstellen. Des Weiteren erstellen Sie zu Testzwecken ein MSTest-Projekt für .NET.

Die vollständige C#-Projektmappe kann aus dem Repository MicrosoftDocs/visualstudio-docs auf GitHub heruntergeladen werden.

Voraussetzungen

Für dieses Tutorial ist die Installation von Visual Studio Enterprise mit der Workload .NET-Desktopentwicklung erforderlich.

Projektmappe und Klassenbibliotheksprojekt erstellen

Erstellen Sie zunächst eine Visual Studio-Projektmappe mit dem Namen „UtilityLibraries“, die das einfache .NET-Klassenbibliotheksprojekt „StringLibrary“ enthält.

Die Projektmappe ist nur ein Container für mindestens ein Projekt. Zum Erstellen einer leeren Projektmappe öffnen Sie Visual Studio und führen die folgenden Schritte aus:

Klicken Sie in der Menüleiste von Visual Studio auf Datei>Neu>Projekt.
Geben Sie Projektmappe in das Vorlagensuchfeld ein, und wählen Sie dann die Vorlage Leere Projektmappe aus. Geben Sie dem Projekt den Namen UtilityLibraries.
Schließen Sie das Erstellen der Projektmappe ab.

Nach der Erstellung der Projektmappe erstellen Sie eine Klassenbibliothek mit dem Namen StringLibrary, die einige Erweiterungsmethoden für das Arbeiten mit Zeichenfolgen enthält.

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe UtilityLibraries, und wählen Sie Hinzufügen>Neues Projekt aus.
Geben Sie Klassenbibliothek in das Vorlagensuchfeld ein, und wählen Sie die Vorlage Klassenbibliothek für .NET oder .NET Standard aus. Klicken Sie auf Weiter.
Nennen Sie das Projekt StringLibrary .
Klicken Sie auf Erstellen, um das Projekt zu erstellen.

Ersetzen Sie sämtlichen vorhandenen Code im Code-Editor durch den folgenden 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 verfügt über drei statische Methoden:

StartsWithUpper gibt true zurück, wenn eine Zeichenfolge mit einem Großbuchstaben beginnt; andernfalls wird false zurückgegeben.
StartsWithLower gibt true zurück, wenn eine Zeichenfolge mit einem Kleinbuchstaben beginnt; andernfalls wird false zurückgegeben.
HasEmbeddedSpaces gibt true zurück, wenn eine Zeichenfolge mit einem Leerzeichen beginnt; andernfalls wird false zurückgegeben.

Klicken Sie im Hauptebenenmenü von Visual Studio auf Erstellen>Projektmappe. Das Erstellen sollte nun erfolgreich abgeschlossen werden.

Erstellen des Testprojekts

Im nächsten Schritt wird das Komponententestprojekt zum Testen der StringLibrary-Bibliothek erstellt. Führen Sie die folgenden Schritte aus, um die Komponententests zu erstellen:

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe UtilityLibraries, und wählen Sie Hinzufügen>Neues Projekt aus.
Geben Sie im Vorlagensuchfeld Komponententest ein, wählen Sie als Sprache C# und dann die Vorlage MSTest-Komponententestprojekt für .NET aus. Klicken Sie auf Weiter.

Hinweis

In der Version 16.9 von Visual Studio 2019 lautet der MSTest-Projektvorlagenname Komponententestprojekt.
Geben Sie dem Projekt den Namen StringLibraryTests, und klicken Sie auf Weiter.
Wählen Sie entweder das empfohlene Zielframework oder .NET 8 aus, und wählen Sie Erstellen aus.

Hinweis

In dieser Einführung wird das Live Unit Testing mit dem MSTest-Testframework verwendet. Sie können auch die xUnit- und NUnit-Testframeworks verwenden.
Das Komponententestprojekt kann nicht automatisch auf die Klassenbibliothek zugreifen, die getestet wird. Sie erteilen der Testbibliothek Zugriff, indem Sie eine Referenz auf das Klassenbibliotheksprojekt hinzufügen. Klicken Sie dazu mit der rechten Maustaste auf das StringLibraryTests-Projekt, und wählen Sie Hinzufügen>Projektverweis aus. Stellen Sie sicher, dass im Dialogfeld Verweis-Manager die Registerkarte Projektmappe ausgewählt ist, und wählen Sie wie in der folgenden Abbildung gezeigt das Projekt „StringLibrary“ aus.

Ersetzen Sie den in der Vorlage angegebenen Codebaustein für den Komponententest durch den folgenden 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}");
            }
        }
    }
}

Speichern Sie Ihr Projekt, indem Sie auf das Symbol Speichern in der Symbolleiste klicken.

Da der Komponententestcode einige ASCII-fremde Zeichen enthält, wird das folgende Dialogfeld mit der Warnung angezeigt, dass einige Zeichen verloren gehen, wenn die Datei im ASCII-Standardformat gespeichert wird.
Klicken Sie auf die Schaltfläche Mit anderer Codierung speichern.
Wählen Sie wie in der folgenden Abbildung gezeigt in der Dropdownliste Codierung des Dialogfelds Erweiterte Speicheroptionen die Option Unicode (UTF-8 ohne Signatur) – Codepage 65001 aus:
Kompilieren Sie das Komponententestprojekt, indem Sie im Hauptebenenmenü von Visual Studio auf Erstellen>Projektmappe neu erstellen klicken.

Sie haben eine Klassenbibliothek und einige Komponententests dafür erstellt. Sie haben nun die Vorbereitungen abgeschlossen, die für die Verwendung von Live Unit Testing erforderlich sind.

Aktivieren von Live Unit Testing

Bisher haben Sie die Tests für die StringLibrary-Klassenbibliothek zwar geschrieben, jedoch nicht ausgeführt. Live Unit Testing macht dies automatisch, nachdem es aktiviert wurde. Führen Sie hierzu die folgenden Schritte aus:

Wählen Sie optional das Code-Editor-Fenster aus, das den Code für StringLibrary enthält. Dies ist entweder Class1.cs für ein C#-Projekt oder Class1.vb für ein Visual Basic-Projekt. (In diesem Schritt können Sie nach der Aktivierung von Live Unit Testing das Ergebnis Ihrer Tests und die Reichweite Ihrer Code Coverage prüfen.)
Klicken Sie im Hauptebenenmenü von Visual Studio auf Test>Live Unit Testing>Starten.
Überprüfen Sie die Konfiguration für das Live Unit Testing, indem Sie sicherstellen, dass der Repositorystamm den Pfad zu den Quelldateien für das Hilfsprojekt und das Testprojekt enthält. Wählen Sie Weiter und dann Fertig stellen aus.

Wählen Sie im Fenster „Live Unit Testing“ den Link Alle Tests einschließen aus. Wählen Sie alternativ das Symbol für die Wiedergabeliste und dann StringLibraryTest aus. Dadurch werden alle Tests unterhalb ausgewählt. Deaktivieren Sie dann die Schaltfläche Wiedergabeliste, um den Bearbeitungsmodus zu beenden.
Visual Studio erstellt das Projekt neu und startet den Live Unit Test, der automatisch alle Ihre Tests ausführt.

Visual Studio erstellt das Projekt neu und startet den Live Unit Test, der automatisch alle Ihre Tests ausführt.

Nach Abschluss der Testausführung zeigt Live Unit Testing die Gesamtergebnisse und die Ergebnisse der einzelnen Tests an. Darüber hinaus werden sowohl die Code Coverage als auch die Ergebnisse Ihrer Tests im Code-Editor-Fenster angezeigt. Alle drei Tests wurden wie in der folgenden Abbildung gezeigt erfolgreich ausgeführt. Zudem ist zu sehen, dass die Tests alle Codepfade in der Methode StartsWithUpper abgedeckt haben, und dass diese Tests alle erfolgreich ausgeführt wurden (durch das grüne Häkchen „✓“ gekennzeichnet). Schließlich ist zu sehen, dass keine der anderen Methoden in StringLibrary über eine Code Coverage verfügt (dies wird durch eine blaue Linie „➖“ gekennzeichnet).

Live Test-Explorer- und Code-Editor-Fenster nach Start von Live Unit Testing

Ausführlichere Informationen zu Testabdeckung und Testergebnissen erhalten Sie, indem Sie im Code-Editor-Fenster ein bestimmtes Code Coverage-Symbol auswählen. Gehen Sie wie folgt vor, um diese Details zu prüfen:

Klicken Sie in der Zeile, in der if (String.IsNullOrWhiteSpace(s)) bei der Methode StartsWithUpper steht, auf das grüne Häkchen. Live Unit Testing gibt wie in der folgenden Abbildung gezeigt an, dass drei Tests die Codezeile abdecken, und dass alle erfolgreich ausgeführt wurden.
Klicken Sie in der Zeile, in der return Char.IsUpper(s[0]) bei der Methode StartsWithUpper steht, auf das grüne Häkchen. Live Unit Testing gibt wie in der folgenden Abbildung gezeigt an, dass nur zwei Tests die Codezeile abdecken, und dass alle erfolgreich ausgeführt wurden.

Das größte, von Live Unit Testing ermittelte Problem ist die unvollständige Code Coverage. Dieses Problem wird im nächsten Abschnitt behandelt.

Erweitern der Testabdeckung

In diesem Abschnitt erweitern Sie die Komponententests um die Methode StartsWithLower. Während Sie dies tun, testet Live Unit Testing Ihren Code weiterhin dynamisch.

Gehen Sie wie folgt vor, um die Code Coverage um die Methode StartsWithLower zu erweitern:

Fügen Sie die folgenden Methoden TestStartsWithLower und TestDoesNotStartWithLower zur Testquellcodedatei Ihres Projekts hinzu:

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

Ändern Sie die Methode DirectCallWithNullOrEmpty, indem Sie den folgenden Code direkt nach dem Aufruf zur Methode Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse hinzufügen.

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

Wenn Sie Ihren Quellcode ändern, führt Live Unit Testing automatisch neue und geänderte Tests aus. Alle Tests, einschließlich der zwei, die Sie hinzugefügt haben, und dem einen, den Sie geändert haben, wurden wie in der folgenden Abbildung gezeigt erfolgreich ausgeführt.
Wechseln Sie zu dem Fenster mit dem Quellcode für die Klasse StringLibrary. Live Unit Testing zeigt jetzt an, dass Ihre Code Coverage um die Methode StartsWithLower erweitert wurde.

In einigen Fällen sind erfolgreich ausgeführte Tests im Test-Explorer grau unterlegt. Dies deutet darauf hin, dass gerade ein Test ausgeführt wird oder dass der Test nicht erneut ausgeführt wurde, da keine Codeänderungen vorgenommen wurden, die seit seiner letzten Ausführung Auswirkungen auf den Test haben würden.

Bisher wurden alle Tests erfolgreich abgeschlossen. Im nächsten Abschnitt untersuchen wir, wie Sie Testfehler behandeln können.

Behandeln eines Testfehlers

In diesem Abschnitt lernen Sie, wie Sie mithilfe von Live Unit Testing Testfehler ermitteln, behandeln und beheben können. Hierzu müssen Sie die Testabdeckung um die Methode HasEmbeddedSpaces erweitern.

Fügen Sie die folgende Methode zu Ihrer Testdatei hinzu:

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

Wenn der Test ausgeführt wird, gibt Live Unit Testing wie in der folgenden Abbildung gezeigt an, dass die TestHasEmbeddedSpaces-Methode fehlgeschlagen ist:
Wählen Sie das Fenster aus, in dem der Bibliothekscode angezeigt wird. Live Unit Testing hat die Code Coverage um die HasEmbeddedSpaces-Methode erweitert. Außerdem wird das Fehlschlagen von Tests durch ein rotes „“ in den Zeilen, die von fehlgeschlagenen Tests betroffen sind, angezeigt.
Zeigen Sie auf die Zeile mit der HasEmbeddedSpaces-Methodensignatur. Live Unit Testing zeigt wie in der folgenden Abbildung gezeigt eine QuickInfo an, die angibt, dass die Methode von einem Test abgedeckt wird:
Wählen Sie den fehlerhaften Test TestHasEmbeddedSpaces aus. Live Unit Testing bietet Ihnen wie in der folgenden Abbildung gezeigt einige Optionen wie das Ausführen aller Tests und das Debuggen aller Tests:
Klicken Sie auf Alle debuggen, um den fehlgeschlagenen Test zu debuggen.
Visual Studio führt den Test im Debugmodus aus.

Der Test weist jede Zeichenfolge in einem Array einer Variablen mit dem Namen phrase zu und übergibt sie an die HasEmbeddedSpaces-Methode. Die Ausführung des Programms wird angehalten, und wenn der Assert-Ausdruck erstmalig false lautet, wird der Debugger abgerufen. Das Ausnahmedialogfeld, das aus dem unerwarteten Wert im Aufruf der Methode Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue resultiert, wird in der folgenden Abbildung gezeigt.

Darüber hinaus sind alle von Visual Studio bereitgestellten Debugtools verfügbar, um die Fehlerbehebung bei nicht erfolgreichen Tests zu unterstützen. Dies wird in der folgenden Abbildung veranschaulicht:

Beachten Sie im Fenster Auto, dass der Wert der Variable phrase „Name\tDescription“ lautet und damit dem zweiten Element des Arrays entspricht. Von der Testmethode wird erwartet, dass die Methode HasEmbeddedSpaces bei der Übergabe dieser Zeichenfolge den Wert true zurückgibt; stattdessen wird der Wert false zurückgegeben. Offenbar erkennt die Methode das Tabstoppzeichen „\t“ nicht als eingebettetes Leerzeichen.
Klicken Sie auf Debuggen>Fortfahren, drücken Sie F5, oder klicken Sie in der Symbolleiste auf die Schaltfläche Fortfahren, um mit der Ausführung des Testprogramms fortzufahren. Der Test wird aufgrund eines Ausnahmefehlers beendet. Die gelieferten Informationen sind für eine vorläufige Untersuchung des Fehlers ausreichend. Sämtliche eingebettete Leerzeichen werden entweder dadurch, dass TestHasEmbeddedSpaces (die Testroutine) von falschen Voraussetzungen ausgeht, oder von HasEmbeddedSpaces nicht ordnungsgemäß erkannt.
Starten Sie mit der StringLibrary.HasEmbeddedSpaces-Methode, um das Problem zu diagnostizieren und zu beheben. Sehen Sie sich den Vergleich in der HasEmbeddedSpaces-Methode an. Darin wird angenommen, dass U+0020 für ein eingebettetes Leerzeichen steht. Der Unicode-Standard enthält jedoch mehrere andere Leerzeichen. Dies deutet darauf hin, dass der Bibliothekscode nicht ordnungsgemäß auf ein Leerzeichen getestet wurde.
Ersetzen Sie den Übereinstimmungsvergleich durch einen Aufruf der System.Char.IsWhiteSpace-Methode:
```
if (Char.IsWhiteSpace(ch))
```
Live Unit Testing führt die fehlgeschlagene Testmethode automatisch wieder aus.

Live Unit Testing zeigt die aktualisierten Ergebnisse an, die auch im Code-Editor angezeigt werden.