Alessandro Del Sole's Blog

{ A programming space about Microsoft® .NET® }
posts - 1908, comments - 2047, trackbacks - 352

My Links

News

Your host

This is me! Questo spazio è dedicato a Microsoft® .NET®, di cui sono molto appassionato :-)

Cookie e Privacy

Disabilita cookie ShinyStat

Microsoft MVP

My MVP Profile

Microsoft Certified Professional

Microsoft Specialist

Xamarin Certified Mobile Developer

Il mio libro su VB 2015!

Pre-ordina il mio libro su VB 2015 Pre-ordina il mio libro "Visual Basic 2015 Unleashed". Clicca sulla copertina per informazioni!

Il mio libro su WPF 4.5.1!

Clicca sulla copertina per informazioni! E' uscito il mio libro "Programmare con WPF 4.5.1". Clicca sulla copertina per informazioni!

These postings are provided 'AS IS' for entertainment purposes only with absolutely no warranty expressed or implied and confer no rights.
If you're not an Italian user, please visit my English blog

Le vostre visite

I'm a VB!

Guarda la mia intervista a Seattle

Follow me on Twitter!

Altri spazi

GitHub
I miei progetti open-source su GitHub

Article Categories

Archives

Post Categories

Image Galleries

Privacy Policy

Introduzione allo unit testing con Visual Basic 2008

Avrete probabilmente spesso sentito parlare dello unit testing e magari avete anche visto i miei webcast su Microsoft Be-It al riguardo. Poiché a volte avere un riferimento scritto, oltre a quello video, può essere utile, scrivo questo post introduttivo allo unit testing con Visual Studio 2008 nei confronti di applicazioni Visual Basic, con particolare riguardo all’introduzione della strumentazione. Probabilmente molti di voi ricorrono a strumenti esterni a Visual Studio per porre in essere tale pratica. In realtà, le edizioni di Visual Studio 2008 a partire dalla Professional e superiori dispongono di una specifica strumentazione per lo unit testing.

 

Una precisazione: questo primo post è introduttivo, quindi focalizza l’attenzione su alcune caratteristiche della strumentazione, più che sul codice che sarà invece piuttosto essenziale. In successivi post, invece, vedremo anche come utilizzare la strumentazione su codice più complesso.

 

In breve, lo unit testing consente di testare il funzionamento di un blocco di codice “astraendolo” da quello che è il suo contesto all’interno della nostra applicazione (paroloni che spiegheremo poi con un esempio). Tipicamente il codice sottoposto a unit testing è costituito da metodi che restituiscono qualcosa, quindi delle Function. Vediamo come funziona per poi dettagliarne gli aspetti.

In primo luogo, creiamo un progetto Visual Basic per la Console. Immaginiamo di voler creare un’applicazione che calcoli il prodotto di due numeri immessi dall’utente. Una cosa del tutto semplice, dovendo focalizzare l’attenzione sullo unit testing.

 

L’utente immetterà due valori su nostra richiesta e poi verrà eseguito il calcolo:

 

    Sub Main()

        Console.WriteLine("Inserisci il primo numero:")

        'Per praticità faccio una conversione diretta

        'ma potrei utilizzare Double.TryParse per validazione

        Dim firstNumber As Double? = CDbl(Console.ReadLine)

        Console.WriteLine("Inserisci il secondo numero:")

        Dim secondNumber As Double? = CDbl(Console.ReadLine)

 

        Console.WriteLine("Il risultato è {0}", Multiply(firstNumber, _

                          secondNumber).ToString)

        Console.ReadLine()

    End Sub

 

Il metodo che esegue la moltiplicazione, chiamato con sforzo di fantasia Multiply, è decisamente semplice:

 

    Private Function Multiply(ByVal firstNumber As Double?, _

                              ByVal secondNumber As Double?)

        If firstNumber.HasValue = False Then firstNumber = 0

        If secondNumber.HasValue = False Then secondNumber = 0

 

        Return firstNumber * secondNumber

    End Function

 

Ora supponiamo di voler eseguire lo unit testing di questo metodo. Posizioniamo il cursore sul nome del metodo, facciamo clic destro e scegliamo il comando Create Unit Tests:

Comparirà la finestra Create Unit Tests, dalla quale potremo selezionare le porzioni di codice da sottoporre a test. Per default, Visual Studio propone la selezione del metodo sul quale abbiamo avviato la procedura. Se provate ad espandere i vari nodi, noterete anche che è possibile testare proprietà e metodi di tipo Sub:

Assicuratevi che nella combobox sottostante sia selezionata la voce Create a new Visual Basic test project e poi fate clic su OK. Vi verrà poi richiesto di specificare un nome per il progetto di test, tramite la seguente dialog:

 

E’ probabile che vi verrà chiesto se volete accettare la visibilità di tipo Internal per i membri che sono marcati come Friend. Accettate! Dopo alcuni secondi, Visual Studio 2008 termina la generazione del progetto di test. Nel codice di questo progetto, ci interessano principalmente due cose. Innanzitutto la classe, decorata con l’attributo TestClass proprio ad indicare che si tratta di un oggetto dedicato all’esecuzione dei test:

 

 

'''<summary>

'''This is a test class for Module1Test and is intended

'''to contain all Module1Test Unit Tests

'''</summary>

<TestClass()> _

Public Class Module1Test

 

Poi la proprietà TestContext, che definisce il contesto di esecuzione dei test:

 

    Private testContextInstance As TestContext

 

    '''<summary>

    '''Gets or sets the test context which provides

    '''information about and functionality for the current test run.

    '''</summary>

    Public Property TestContext() As TestContext

        Get

            Return testContextInstance

        End Get

        Set(ByVal value As TestContext)

            testContextInstance = Value

        End Set

    End Property

 

La parte però di maggiore interesse è costituita da un metodo che Visual Studio ha chiamato MultiplyTest, decorato con l’attributo TestMethod, che è quello che effettivamente testa il nostro codice:

 

    '''<summary>

    '''A test for Multiply

    '''</summary>

    <TestMethod(), _

     DeploymentItem("UnitTestingDemo.exe")> _

    Public Sub MultiplyTest()

        Dim firstNumber As Nullable(Of Double) = New Nullable(Of Double) ' TODO: Initialize to an appropriate value

        Dim secondNumber As Nullable(Of Double) = New Nullable(Of Double) ' TODO: Initialize to an appropriate value

        Dim expected As Object = Nothing ' TODO: Initialize to an appropriate value

        Dim actual As Object

        actual = Module1_Accessor.Multiply(firstNumber, secondNumber)

        Assert.AreEqual(expected, actual)

        Assert.Inconclusive("Verify the correctness of this test method.")

    End Sub

 

Sostanzialmente per svolgere il nostro test dobbiamo:

 

1.    Specificare il primo numero della moltiplicazione

2.    Specificare il secondo numero della moltiplicazione

3.    Specificare il valore che ci attendiamo come restituito

 

Facendo un discorso più generale, i punti 1 e 2 dovrebbero essere sostituiti con “inizializzare le variabili facenti parte del test con valori che ci permettano di verificare il funzionamento del codice”. Modifichiamo quindi le prime righe del metodo in questo modo:

 

        Dim firstNumber As Nullable(Of Double) = 3

        Dim secondNumber As Nullable(Of Double) = 2

        Dim expected As Double? = 6

        Dim actual As Double?

 

Vogliamo in sostanza verificare che la moltiplicazione di 3 * 2 restituisca effettivamente 6. Nel caso ciò non avvenisse, vorrebbe dire che il codice che esegue il calcolo è sbagliato. Abbiamo anche sostituito il tipo Object con Nullable(Of Double). La riga Assert.Inconclusive può essere rimossa, poiché sta ad indicare che l’implementazione del metodo di test non è completa. Per eseguire il test, dal menu Test selezioniamo Windows -> Test View. Questo farà sì che appaia la finestra ancorabile Test View:

Tale finestra contiene l’elenco di tutti i test methods e possiamo avviare più test in un sol colpo. Per avviare il nostro, facciamo clic sul pulsante Run Selection. Dopo alcuni secondi saremo in grado di vedere il risultato nella finestra Test Results:

Ovviamente in un esempio semplice come il nostro, il test va a buon fine. Ci basta modificare uno dei valori nel codice per vedere cosa succede quando il test fallisce:

Come vedete, la finestra Test Results mostra un messaggio di errore generato dal metodo Assert.AreEqual, indicando il valore atteso e quello effettivamente ottenuto.

 

In tutto questo, vi sarete forse accorti che non abbiamo coinvolto l’applicazione originaria. Lo scopo è proprio quello di fare test di codice in modo indipendente dall’applicazione che usa il codice stesso.

 

In successivi post vedremo ulteriori funzionalità della strumentazione (es. Code Coverage) e la scrittura di codice un po’ più complesso, analizzando anche due specifici file che vengono aggiunti alla soluzione (.TestRunConfig e .vsmdi) con riferimento alle funzionalità di test.

 

Alessandro

Print | posted on martedì 21 luglio 2009 14:27 | Filed Under [ Visual Basic Visual Studio 2008 ]

Powered by:
Powered By Subtext Powered By ASP.NET