(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

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

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.

HinweisHinweis

Auf Ihrem Computer werden möglicherweise andere Namen oder Speicherorte für die Benutzeroberflächenelemente von Visual Studio angezeigt als die in den folgenden Anweisungen aufgeführten. Diese Elemente sind von der jeweiligen Visual Studio-Version und den verwendeten Einstellungen abhängig. Weitere Informationen finden Sie unter Anpassen der Entwicklungseinstellungen in Visual Studio.

So erstellen Sie ein Windows-Klassenbibliotheksprojekt und ein Testprojekt

  1. 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.

  2. 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.

  3. In der Vorlagen Bereich, klicken Sie auf Testprojekt Einheit und akzeptieren Sie den Namen des UnitTestProject1. Die folgende Abbildung zeigt das Dialogfeld, wenn es in Visual C# angezeigt wird. In Visual Basic sieht das Dialogfeld ähnlich aus.

    Dialogfeld "Neues Projekt"

    Dialogfeld "Neues Testprojekt"
  4. 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

  1. 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.

  2. 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).

    Hinweis Hinweis

    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 Verwenden von IntelliSense. Beim Eingeben von Automobile im nächsten Schritt ist der Vorschlagsmodus hilfreich.

  3. 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

    Smarttag "Unterstreichen" in Visual Basic
    Visual C#

    Smarttag "Unterstreichen" in C#
  4. 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

    Kontextmenü "Smarttag" in Visual Basic
    Visual C#

    Kontextmenü "Smarttag" in C#
  5. 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"

    Dialogfeld "Neuen Typ generieren"
  6. Klicken Sie auf OK, um das Dialogfeld zu schließen und die neue Datei zu erstellen.

  7. Ü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") && (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

    Kontextmenü "Eigenschaft generieren" in Visual Basic
    Visual C#

    Kontextmenü "Eigenschaft generieren" in 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"

    Dialogfeld "Navigieren zu"

So generieren Sie einen Stub für einen neuen Konstruktor

  1. 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 void AutomobileWithModelNameCanStart()
    {
        string model = "Contoso";
        int topSpeed = 199;
        Automobile myAuto = new Automobile(model, topSpeed);
    }
    
    
    
  2. 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.)

  3. 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

  1. 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);
    
    
    
  2. Klicken Sie auf das Smarttag für den myAuto.Start-Methodenaufruf und dann auf Methodenstub generieren.

  3. 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
    {
        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

  1. Auf der Unit Test auf Komponententests ausführen, und klicken Sie dann auf Alle Tests. 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

    Testergebnisse mit Fehlern
  2. Doppelklicken Sie im Fenster Testergebnisse auf jede Testergebniszeile, um zu der Stelle zu wechseln, an der die einzelnen Testfehler aufgetreten sind.

So implementieren Sie den Quellcode

  1. 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.

    
    public Automobile()
    {
        this.Model = "Not specified";
        this.TopSpeed = -1;
        this.IsRunning = true;
    }
    
    
    
  2. 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.

    
    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

    Testergebnisse ohne Fehler

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft