Exemplarische Vorgehensweise: Test-First-Unterstützung mit der Funktion "Generate From Usage"

Artikel
08/10/2011

Dieses Thema veranschaulicht, wie die Funktion Generate From Usage verwendet wird, die die Test-First-Entwicklung unterstützt.

Die Test-First-Entwicklung ist eine Methode für den Softwareentwurf, in der zuerst Komponententests auf Grundlage von Produktspezifikationen erstellt werden und anschließend der Quellcode geschrieben wird, der für den erfolgreichen Verlauf der Tests erforderlich ist. Visual Studio unterstützt die Test-First-Entwicklung, indem neue Typen und Member im Quellcode generiert werden, wenn Sie zuerst in den Testfällen darauf verweisen, bevor sie definiert werden.

Visual Studio generiert die neuen Typen und Member mit nur minimaler Unterbrechung des Workflows. Sie können Stubs für Typen, Methoden, Eigenschaften, Felder oder Konstruktoren erstellen, ohne den aktuellen Speicherort im Code zu verlassen. Wenn Sie ein Dialogfeld öffnen, um Optionen für die Typgenerierung anzugeben, kehrt der Fokus umgehend zur aktuellen geöffneten Datei zurück, wenn das Dialogfeld geschlossen wird.

Die Funktion "Generate From Usage" kann mit Testframeworks verwendet werden, die in Visual Studio integriert werden. In diesem Thema wird das Microsoft-Komponententestframework erläutert.

Tipp

Diese exemplarische Vorgehensweise wurde unter Berücksichtigung von Visual Basic- oder Visual C#-Entwicklungseinstellungen geschrieben. Die exemplarische Vorgehensweise funktioniert auch mit anderen Einstellungen.

Sie können das folgende Verfahren verwenden, um zu den empfohlenen Einstellungen zu wechseln: Klicken Sie im Menü Extras auf Einstellungen importieren und exportieren. Klicken Sie auf der ersten Seite von Assistent zum Importieren und Exportieren von Einstellungen auf Alle Einstellungen zurücksetzen. Klicken Sie auf der Seite Standardauflistung von Eigenschaften auswählen auf Visual Basic-Entwicklungseinstellungen oder Visual C#-Entwicklungseinstellungen.

So erstellen Sie ein Windows-Klassenbibliotheksprojekt und ein Testprojekt

Erstellen Sie in Visual C# oder Visual Basic ein neues Windows-Klassenbibliotheksprojekt. Nennen Sie die Datei GFUDemo_VB oder GFUDemo_CS, abhängig von der verwendeten Sprache.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Symbol oben, zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neues Projekt. Klicken Sie im Bereich Projekttypen des Dialogfelds Neues Projekt auf Test.
Klicken Sie im Bereich Vorlagen auf Testprojekt, und übernehmen Sie den Standardnamen von TestProject1. Die folgende Abbildung zeigt das Dialogfeld, wenn es in Visual C# angezeigt wird. In Visual Basic sieht das Dialogfeld ähnlich aus.

Dialogfeld "Neues Projekt"
Klicken Sie auf OK, um das Dialogfeld Neues Projekt zu schließen. Sie können nun Tests erstellen.

So generieren Sie eine neue Klasse anhand eines Komponententests

Das Testprojekt enthält eine Datei mit dem Namen "UnitTest1". Doppelklicken Sie auf die Datei im Projektmappen-Explorer, um sie im Code-Editor zu öffnen. Eine Testklasse und eine Testmethode wurden generiert.
Suchen Sie die Deklaration für die UnitTest1-Klasse, und benennen Sie sie in AutomobileTest um. Benennen Sie in C# einen UnitTest1()-Konstruktor in AutomobileTest() um (sofern vorhanden).

Tipp

IntelliSense stellt nun zwei Alternativen zur IntelliSense-Anweisungsvervollständigung bereit: den Beendigungsmodus und den Vorschlagsmodus. Verwenden Sie den Vorschlagsmodus, wenn Klassen und Member verwendet werden, bevor sie definiert werden. Wenn ein IntelliSense-Fenster geöffnet ist, können Sie STRG+ALT+LEERTASTE drücken, um zwischen dem Beendigungsmodus und dem Vorschlagsmodus zu wechseln. Weitere Informationen finden Sie unter Member auflisten. Beim Eingeben von Automobile im nächsten Schritt ist der Vorschlagsmodus hilfreich.
Suchen Sie nach der TestMethod1()-Methode, und benennen Sie sie in DefaultAutomobileIsInitializedCorrectly() um. Erstellen Sie wie in den folgenden Abbildungen dargestellt innerhalb dieser Methode eine neue Instanz einer Klasse mit dem Namen Automobile. Ein wellenförmiger Unterstrich wird angezeigt, was einen Kompilierungszeitfehler angibt, und ein Smarttag wird unter dem Typnamen angezeigt. Der genaue Speicherort des Smarttags ändert sich abhängig davon, ob Sie Visual Basic oder Visual C# verwenden.

Visual Basic

Visual C#
Richten Sie den Mauszeiger auf das Smarttag, um eine Fehlermeldung anzuzeigen, die angibt, dass noch kein Typ mit dem Namen Automobile definiert wurde. Klicken Sie auf das Smarttag, oder drücken Sie STRG+. (STRG+PUNKT), um das Kontextmenü "Generate From Usage" zu öffnen (siehe folgende Darstellungen).

Visual Basic

Visual C#
Sie haben nun zwei Möglichkeiten. Sie können auf 'Class Automobile' generieren klicken, um eine neue Datei im Testprojekt zu erstellen und sie mit einer Klasse mit dem Namen Automobile aufzufüllen. Dies ist eine schnelle Möglichkeit, in einer neuen Datei, die über standardmäßige Zugriffsmodifizierer verfügt, eine neue Klasse zu erstellen. Sie können auch auf Neuen Typ generieren klicken, um das Dialogfeld Neuen Typ generieren zu öffnen. Dadurch erhalten Sie Zugriff auf Optionen, die das Platzieren der Klasse in einer vorhandenen Datei und das Hinzufügen der Datei zu einem anderen Projekt einschließen.

Klicken Sie auf Neuen Typ generieren, um das Dialogfeld Neuen Typ generieren zu öffnen, das in der folgenden Abbildung gezeigt wird. Klicken Sie in der Liste Projekt auf GFUDemo_VB oder GFUDemo_CS, um Visual Studio anzuweisen, dem Quellcodeprojekt anstelle des Testprojekts die Datei hinzuzufügen.

Dialogfeld "Neuen Typ generieren"
Klicken Sie auf OK, um das Dialogfeld zu schließen und die neue Datei zu erstellen.
Überprüfen Sie im Projektmappen-Explorer unter dem Projektknoten "GFUDemo_VB" oder "GFUDemo_CS", ob die neue Datei "Automobile.vb" oder "Automobile.cs" vorhanden ist. Im Code-Editor ist der Fokus immer noch in AutomobileTest.DefaultAutomobileIsInitializedCorrectly. Sie können weiterhin den Test mit nur minimaler Unterbrechung erstellen (schreiben).

So generieren Sie einen Eigenschaftenstub

Angenommen, die Produktspezifikation gibt an, dass die Automobile-Klasse über zwei öffentliche Eigenschaften mit dem Namen von Model und TopSpeed verfügt. Diese Eigenschaften müssen mit den Standardwerten "Not specified" und -1 vom Standardkonstruktor initialisiert werden. Im folgenden Komponententest wird überprüft, ob der Standardkonstruktor die Eigenschaften auf ihre richtigen Standardwerte festlegt.

Fügen Sie DefaultAutomobileIsInitializedCorrectly die folgende Codezeile hinzu.
```
Assert.IsTrue((myAuto.Model = "Not specified") And (myAuto.TopSpeed = -1))
```
```
Assert.IsTrue((myAuto.Model == "Not specified") && (myAuto.TopSpeed == -1));
```
Da der Code auf zwei nicht definierte Eigenschaften für Automobile verweist, wird ein Smarttag angezeigt. Klicken Sie auf das Smarttag für Model und dann auf Eigenschaftenstub generieren. Generieren Sie auch einen Eigenschaftenstub für die TopSpeed-Eigenschaft.

In der Automobile-Klasse werden die Typen der neuen Eigenschaften korrekt aus dem Kontext abgeleitet.

Die folgende Abbildung zeigt das Kontextmenü des Smarttags.

Visual Basic

Visual C#

So suchen Sie den Quellcode

Verwenden Sie die Funktion Navigieren zu, um zur Quellcodedatei "Automobile.cs" oder "Automobile.vb" zu navigieren, damit Sie überprüfen können, ob die neuen Eigenschaften generiert wurden.

Die Funktion Navigieren zu ermöglicht es Ihnen, rasch eine Textzeichenfolge einzugeben (z. B. einen Typnamen oder den Teil eines Namens) und durch Klicken auf das Element in der Ergebnisliste zum gewünschten Ort zu wechseln.

Öffnen Sie das Dialogfeld Navigieren zu durch Klicken im Code-Editor und Drücken von STRG+, (STRG+Komma). Geben Sie im Textfeld automobile ein. Klicken Sie in der Liste auf die Automobile-Klasse, und klicken Sie dann auf OK.

Das Fenster Navigieren zu wird in der folgenden Abbildung gezeigt.

Fenster "Navigieren zu"

So generieren Sie einen Stub für einen neuen Konstruktor

In dieser Testmethode generieren Sie einen Konstruktorstub, der die Model-Eigenschaft und die TopSpeed-Eigenschaft initialisiert, damit die angegebenen Werte verfügbar sind. Später fügen Sie weiteren Code hinzu, um den Test abzuschließen. Fügen Sie der AutomobileTest-Klasse die folgende zusätzliche Testmethode hinzu.

<TestMethod()> Public Sub AutomobileWithModelNameCanStart()
    Dim model As String = "Contoso"
    Dim topSpeed As Integer = 199
    Dim myAuto As New Automobile(model, topSpeed)
End Sub

[TestMethod]
public void AutomobileWithModelNameCanStart()
{
    string model = "Contoso";
    int topSpeed = 199;
    Automobile myAuto = new Automobile(model, topSpeed);
}

Klicken Sie auf das Smarttag unter dem neuen Klassenkonstruktor und anschließend auf Konstruktorstub generieren. Beachten Sie in der Klassendatei Automobile, dass der neue Konstruktor die Namen der lokalen Variablen geprüft hat, die im Konstruktoraufruf verwendet werden, Eigenschaften gefunden hat, die über die gleichen Namen in der Automobile-Klasse verfügen, und Code im Konstruktortext bereitgestellt hat, um die Argumentwerte in der Model-Eigenschaft und TopSpeed-Eigenschaft zu speichern. (In Visual Basic sind die Felder _model und _topSpeed im neuen Konstruktor die implizit definierten dahinter liegenden Felder für die Model-Eigenschaft und die TopSpeed-Eigenschaft.)
Nach dem Generieren des neuen Konstruktors erscheint eine wellenförmige Unterstrichlinie unter dem Aufruf des Standardkonstruktors in DefaultAutomobileIsInitializedCorrectly. Die Fehlermeldung gibt an, dass die Automobile-Klasse über keinen Konstruktor verfügt, der 0 (null) Argumente erhält. Um einen expliziten Standardkonstruktor zu generieren, der nicht über Parameter verfügt, klicken Sie auf das Smarttag und dann auf Konstruktorstub generieren.

So generieren Sie einen Stub für eine Methode

Angenommen, die Spezifikation gibt an, dass ein neues Automobile in einen aktiven Zustand gesetzt werden kann, wenn die entsprechende Model-Eigenschaft und die TopSpeed-Eigenschaft auf andere Werte als die Standardwerte festgelegt werden. Fügen Sie der AutomobileWithModelNameCanStart-Methode die folgenden Zeilen hinzu.
```
myAuto.Start()
Assert.IsTrue(myAuto.IsRunning = True)
```
```
myAuto.Start();
Assert.IsTrue(myAuto.IsRunning == true);
```
Klicken Sie auf das Smarttag für den myAuto.Start-Methodenaufruf und dann auf Methodenstub generieren.

Klicken Sie auf das Smarttag für die IsRunning-Eigenschaft und dann auf Eigenschaftenstub generieren. Die Automobile-Klasse enthält nun den folgenden Code.

Public Class Automobile
    Sub New(ByVal model As String, ByVal topSpeed As Integer)
        _model = model
        _topSpeed = topSpeed
    End Sub
    Sub New()
        ' TODO: Complete member initialization 
    End Sub

    Property Model() As String
    Property TopSpeed As Integer
    Property IsRunning As Boolean
    Sub Start()
        Throw New NotImplementedException
    End Sub
End Class

public class Automobile
{
    public string Model { get; set; }
    public int TopSpeed { get; set; }

    public Automobile(string model, int topSpeed)
    {
        this.Model = model;
        this.TopSpeed = topSpeed;
    }

    public Automobile()
    {
        // TODO: Complete member initialization
    }

    public void Start()
    {
        throw new NotImplementedException();
    }

    public bool IsRunning { get; set; }
}

So führen Sie Tests aus

Zeigen Sie im Menü Test auf Ausführen, und klicken Sie anschließend auf Alle Tests in der Projektmappe. Mit diesem Befehl werden alle Tests in sämtlichen Testframeworks ausgeführt, die für die aktuelle Lösung geschrieben werden.

In diesem Fall gibt es zwei Tests, die beide erwartungsgemäß fehlschlagen. Der DefaultAutomobileIsInitializedCorrectly-Test schlägt fehl, da die Assert.IsTrue-Bedingung False zurückgibt. Der AutomobileWithModelNameCanStart-Test schlägt fehl, da durch die Start-Methode in der Automobile-Klasse eine Ausnahme ausgelöst wird.

Das Fenster Testergebnisse wird in der folgenden Abbildung gezeigt.

Fenster für Testergebnisse
Doppelklicken Sie im Fenster Testergebnisse auf jede Testergebniszeile, um zu der Stelle zu wechseln, an der die einzelnen Testfehler aufgetreten sind.

Tipp

Wenn Sie durch Doppelklicken nicht zum Testfehler im Code gelangen, können Sie diese Funktion aktivieren, indem Sie das folgende Verfahren ausführen: Klicken Sie im Menü Extras auf Optionen, erweitern Sie dann Testtools, und klicken Sie auf Testausführung. Aktivieren Sie das Kontrollkästchen Durch Doppelklick auf ein Komponententestergebnis mit dem Status "Fehler" oder "Nicht eindeutig" können Sie die Stelle anzeigen, an der der Fehler aufgetreten ist.

So implementieren Sie den Quellcode

Fügen Sie dem Standardkonstruktor den folgenden Code hinzu, damit die Model-Eigenschaft, die TopSpeed-Eigenschaft und die IsRunning-Eigenschaft alle mit den richtigen Standardwerten "Not specified", -1 und True (true) initialisiert werden.
```
Sub New()
    Model = "Not specified"
    TopSpeed = -1
    IsRunning = True
End Sub
```
```
public Automobile()
{
    this.Model = "Not specified";
    this.TopSpeed = -1;
    this.IsRunning = true;
}
```

Wenn die Start-Methode aufgerufen wird, sollte sie das IsRunning-Flag nur dann auf "true" festlegen, wenn die Model- oder TopSpeed-Eigenschaften nicht auf den Standardwert festgelegt sind. Entfernen Sie NotImplementedException aus dem Methodentext, und fügen Sie den folgenden Code hinzu.

Sub Start()
    If Model <> "Not specified" Or TopSpeed <> -1 Then
        IsRunning = True
    Else
        IsRunning = False
    End If
End Sub

public void Start()
{
    if (this.Model != "Not specified" || this.TopSpeed != -1)
        this.IsRunning = true;
    else
        this.IsRunning = false;
}

So führen Sie erneut die Tests aus

Zeigen Sie im Menü Test auf Ausführen, und klicken Sie anschließend auf Alle Tests in der Projektmappe. Dieses Mal wurde der Test erfolgreich abgeschlossen. Das Fenster Testergebnisse wird in der folgenden Abbildung gezeigt.

Fenster für Testergebnisse

Siehe auch

Freigeben über