Procedura dettagliata: supporto test preliminare con la funzionalità di generazione dall'utilizzo

Articolo
08/11/2011

In questo argomento viene illustrato come utilizzare la funzionalità Generazione dall'utilizzo che supporta lo sviluppo con test preliminare.

Lo sviluppo con test preliminare è un approccio alla progettazione software in cui vengono prima scritti unit test in base alle specifiche del prodotto, quindi viene scritto il codice sorgente necessario per ottenere risultati positivi nei test. Visual Studio supporta lo sviluppo con test preliminare tramite la generazione di nuovi tipi e membri nel codice sorgente quando vi viene fatto riferimento nei test case, prima che siano definiti.

Visual Studio genera nuovi tipi e membri con una minima interruzione del flusso di lavoro. È possibile creare stub per tipi, metodi, proprietà, campi o costruttori senza lasciare il percorso corrente nel codice. Quando si apre una finestra di dialogo per specificare opzioni per la generazione del tipo, lo stato attivo torna immediatamente al file aperto una volta chiusa la finestra.

La funzionalità di generazione dall'utilizzo può essere utilizzata con framework di test che si integrano con Visual Studio. In questo argomento, viene illustrato il framework per unit test di Microsoft.

Nota

Questa procedura dettagliata è stata scritta utilizzando le impostazioni di sviluppo di Visual Basic o di Visual C#. La procedura dettagliata funzionerà anche con altre impostazioni.

Per passare alle impostazioni consigliate, scegliere Importa/Esporta impostazioni nel menu Strumenti. Nella prima pagina di Importazione/Esportazione guidata delle impostazioni fare clic su Reimposta tutte le impostazioni. Nella pagina Scegliere un insieme di impostazioni predefinito fare clic su Impostazioni di sviluppo di Visual Basic o Impostazioni di sviluppo di Visual C#.

Per creare un progetto di libreria di classi Windows e un progetto di test

In Visual C# o Visual Basic, creare un nuovo progetto di libreria di classi Windows. Denominarlo GFUDemo_VB o GFUDemo_CS, in base al linguaggio utilizzato.
In Esplora soluzioni fare clic con il pulsante destro del mouse sull'icona della soluzione presente nella parte superiore, selezionare Aggiungi, quindi Nuovo progetto. Nella finestra di dialogo Nuovo progetto selezionare Test nel riquadro a sinistra Tipi progetto.
Nel riquadro Modelli fare clic su Progetto di test e accettare il nome predefinito TestProject1. Nella figura riportata di seguito viene mostrata la finestra di dialogo visualizzata in Visual C#. In Visual Basic, viene visualizzata una finestra di dialogo simile.

Finestra di dialogo Nuovo progetto
Scegliere OK per chiudere la finestra di dialogo Nuovo progetto. A questo punto è possibile iniziare a scrivere i test

Per generare una nuova classe da uno unit test

Il progetto di test contiene un file denominato UnitTest1. In Esplora soluzioni fare doppio clic su questo file per aprirlo nell'editor di codice. Sono stati generati una classe di test e un metodo di test.
Individuare la dichiarazione per la classe UnitTest1 e rinominarla AutomobileTest. In C#, se esiste un costruttore UnitTest1(), rinominarlo AutomobileTest().

Nota

In IntelliSense sono ora disponibili due alternative per il completamento di istruzioni in IntelliSense: la modalità di terminazione e la modalità di suggerimento. Utilizzare la modalità di suggerimento per le situazioni in cui si utilizzano classi e membri prima di definirli. Quando è aperta una finestra IntelliSense, è possibile premere CTRL+ALT+BARRA SPAZIATRICE per passare dalla modalità di terminazione alla modalità di suggerimento e viceversa. Per ulteriori informazioni, vedere Elenca membri. La modalità di suggerimento sarà utile per la digitazione di Automobile nel passaggio successivo.
Individuare il metodo TestMethod1() e rinominarlo in DefaultAutomobileIsInitializedCorrectly(). All'interno del metodo creare una nuova istanza di una classe denominata Automobile, come illustrato di seguito. Viene visualizzata una sottolineatura ondulata che indica un errore in fase di compilazione e viene visualizzato uno smart tag sotto il nome del tipo. Il percorso esatto dello smart tag varia, a seconda se si utilizza Visual Basic o Visual C#.

Visual Basic

Visual C#
Lasciare il puntatore del mouse sullo smart tag per visualizzare un messaggio di errore che dichiara che non è ancora stato definito alcun tipo denominato Automobile. Fare clic sullo smart tag o premere CTRL+. (CTRL+punto) per aprire il menu di scelta rapida della funzionalità di generazione dall'utilizzo, come mostrato nelle illustrazioni seguenti.

Visual Basic

Visual C#
Ora si dispone di due opzioni. È possibile fare clic su Genera 'Class Automobile' per creare un nuovo file nel progetto di test e inserirvi una classe vuota denominata Automobile. Si tratta di una soluzione rapida per creare una nuova classe in un nuovo file che dispone di modificatori di accesso predefiniti nel progetto corrente. È anche possibile fare clic su Genera nuovo tipo per aprire la finestra di dialogo Genera nuovo tipo. Questo fornisce opzioni che includono l'inserimento della classe in un file esistente e l'aggiunta del file a un altro progetto.

Fare clic su Genera nuovo tipo per aprire la finestra di dialogo Genera nuovo tipo, mostrata nell'illustrazione seguente. Nell'elenco Progetto, fare clic su GFUDemo_VB o GFUDemo_CS per indicare a Visual Studio di aggiungere il file al progetto di codice sorgente anziché al progetto di test.

Finestra di dialogo Genera nuovo tipo
Fare clic su OK per chiudere la finestra di dialogo e creare il nuovo file.
In Esplora soluzioni, esaminare il nodo di progetto GFUDemo_VB o GFUDemo_CS per verificare che sia presente il nuovo file Automobile.vb o Automobile.cs. Nell'editor di codice, lo stato attivo è ancora in AutomobileTest.DefaultAutomobileIsInitializedCorrectly. È possibile continuare a scrivere il test con un'interruzione minima.

Per generare uno stub proprietà

Si supponga che la specifica del prodotto indichi che la classe Automobile dispone di due proprietà pubbliche denominate Model e TopSpeed. Queste proprietà devono essere inizializzate con valori predefiniti di "Not specified" e -1 dal costruttore predefinito. Il seguente unit test consente di verificare che il costruttore predefinito imposti le proprietà sui valori predefiniti corretti.

Aggiungere la seguente riga di codice a DefaultAutomobileIsInitializedCorrectly.
```
Assert.IsTrue((myAuto.Model = "Not specified") And (myAuto.TopSpeed = -1))
```
```
Assert.IsTrue((myAuto.Model == "Not specified") && (myAuto.TopSpeed == -1));
```
Poiché il codice fa riferimento a due proprietà non definite su Automobile, viene visualizzato uno smart tag. Fare clic sullo smart tag relativo a Model, quindi fare clic su Genera stub proprietà. Generare uno stub proprietà anche per la proprietà TopSpeed.

Nella classe Automobile i tipi delle nuove proprietà vengono dedotti correttamente dal contesto.

Nell'illustrazione seguente viene mostrato il menu di scelta rapida dello smart tag.

Visual Basic

Visual C#

Per individuare il codice sorgente

Utilizzare la funzione Passa a per individuare il file del codice sorgente Automobile.cs o Automobile.vb e verificare che siano state generate le nuove proprietà.

La funzionalità Passa a consente di immettere rapidamente una stringa di testo, quale un nome del tipo o una parte di un nome e di andare al percorso desiderato facendo clic sull'elemento nell'elenco di risultati.

Aprire la finestra di dialogo Passa a facendo clic nell'editor del codice e premendo CTRL+, (CTRL+virgola). Digitare automobile nella casella di testo. Fare clic sulla classe Automobile nell'elenco, quindi fare scegliere OK.

Nell'illustrazione seguente viene mostrata la finestra Passa a.

Finestra Passa a

Per generare uno stub per un nuovo costruttore

In questo metodo di test verrà generato uno stub del costruttore che inizializzerà le proprietà Model e TopSpeed in modo che dispongano dei valori specificati. Successivamente, verrà aggiunto ulteriore codice per completare il test. Aggiungere il seguente metodo di test aggiuntivo alla classe AutomobileTest.

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

Fare clic sullo smart tag nel nuovo costruttore di classe, quindi selezionare Genera stub costruttore. Nel file della classe Automobile, si noti che il nuovo costruttore ha esaminato i nomi delle variabili locali utilizzati nella chiamata al costruttore, ha trovato proprietà che hanno gli stessi nomi nella classe Automobile e ha fornito codice nel corpo del costruttore per archiviare i valori dell'argomento nelle proprietà Model e TopSpeed. In Visual Basic, i campi _model e _topSpeed nel nuovo costruttore sono i campi sottostanti definiti in modo implicito per le proprietà Model e TopSpeed.
Dopo aver generato il nuovo costruttore, viene visualizzata una sottolineatura ondulata sotto la chiamata al costruttore predefinito in DefaultAutomobileIsInitializedCorrectly. Il messaggio di errore indica che la classe Automobile non dispone di alcun costruttore che accetta zero argomenti. Per generare un costruttore predefinito esplicito che non dispone di parametri, fare clic sullo smart tag, quindi selezionare Genera stub costruttore.

Per generare uno stub per un metodo

Si supponga che la specifica indichi che è possibile assegnare lo stato In esecuzione a una nuova classe Automobile se le relative proprietà Model e TopSpeed sono impostate su valori diversi da quelli predefiniti. Aggiungere le seguenti righe al metodo AutomobileWithModelNameCanStart.
```
myAuto.Start()
Assert.IsTrue(myAuto.IsRunning = True)
```
```
myAuto.Start();
Assert.IsTrue(myAuto.IsRunning == true);
```
Fare clic sullo smart tag per la chiamata del metodo myAuto.Start, quindi selezionare Genera stub metodo.

Fare clic sullo smart tag per la proprietà IsRunning, quindi selezionare Genera stub proprietà. La classe Automobile adesso contiene il seguente codice.

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

Per eseguire i test

Scegliere Esegui dal menu Test, quindi fare clic su Tutti i test nella soluzione. Questo comando esegue tutti i test in tutti i framework di test scritti per la soluzione corrente.

In questo caso, vengono eseguiti due test ed entrambi non vengono superati, come previsto. Il test DefaultAutomobileIsInitializedCorrectly non viene superato perché la condizione Assert.IsTrue restituisce False. Il test AutomobileWithModelNameCanStart non viene superato perché il metodo Start nella classe Automobile genera un'eccezione.

Nell'illustrazione seguente viene mostrata la finestra Risultati test.

Finestra Risultati test
Nella finestra Risultati test fare doppio clic sulle singole righe dei risultati dei test per passare al percorso di ogni test non superato.

Nota

Se facendo doppio clic non è possibile individuare l'errore del test nel codice, è possibile abilitare questa funzionalità eseguendo la procedura riportata di seguito: nel menu Strumenti fare clic su Opzioni, espandere Strumenti di test, quindi fare clic su Esecuzione dei test. Selezionare la casella di controllo Facendo doppio clic sul risultato Test non superato o Senza risultati di un unit test viene visualizzato il punto in errore del test.

Per implementare il codice sorgente

Aggiungere il seguente codice al costruttore predefinito in modo che le proprietà Model, TopSpeed e IsRunning siano tutte inizializzate ai valori predefiniti corretti di "Not specified", -1 e True (true).
```
Sub New()
    Model = "Not specified"
    TopSpeed = -1
    IsRunning = True
End Sub
```
```
public Automobile()
{
    this.Model = "Not specified";
    this.TopSpeed = -1;
    this.IsRunning = true;
}
```

Quando viene chiamato il metodo Start, il flag IsRunning deve essere impostato su true solo se le proprietà Model o TopSpeed è impostata su un valore diverso da quello predefinito. Rimuovere NotImplementedException dal corpo del metodo e aggiungere il codice seguente.

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

Per eseguire nuovamente i test

Scegliere Esegui dal menu Test, quindi fare clic su Tutti i test nella soluzione. Questa volta i test hanno esito positivo. Nell'illustrazione seguente viene mostrata la finestra Risultati test.

Finestra Risultati test

Vedere anche

Condividi tramite