8. Allegati
8.1. Dove trovare Spring?
Il sito principale di Spring è [http://www.springframework.org/]. Si tratta del sito della versione Java. La versione .NET attualmente in fase di sviluppo (aprile 2005) è disponibile all'URL [http://www.springframework.net/].
Il sito di download è disponibile all’indirizzo [SourceForge]:
Una volta scaricato il file zip sopra indicato, decomprimerlo:
In questo documento abbiamo utilizzato solo il contenuto della cartella [bin]:
In un progetto Visual Studio che utilizza Spring, è necessario eseguire sistematicamente due operazioni:
- inserire i file sopra indicati nella cartella [bin] del progetto
- aggiungere al progetto un riferimento all’assembly [Spring.Core.dll]
8.2. Dove si trova NUnit?
Il sito principale di Nunit è [http://www.nunit.org/]. La versione disponibile nell'aprile 2005 è la 2.2.0:
Scaricate questa versione e installatela. L'installazione crea una cartella in cui si trova la versione grafica di prova:
Ciò che è interessante si trova nella cartella [bin]:
La freccia sopra indica l’utilità grafica di test. L’installazione ha inoltre aggiunto nuovi elementi al repository degli assembly di Visual Studio che scopriremo ora.
Creiamo il seguente progetto Visual Studio:
La classe sottoposta a test si trova in [Personne.vb]:
Public Class Personne
' campi privati
Private _nom As String
Private _age As Integer
' costruttore predefinito
Public Sub New()
End Sub
' proprietà associate ai campi privati
Public Property nom() As String
Get
Return _nom
End Get
Set(ByVal Value As String)
_nom = Value
End Set
End Property
Public Property age() As Integer
Get
Return _age
End Get
Set(ByVal Value As Integer)
_age = Value
End Set
End Property
' stringa di identità
Public Overrides Function tostring() As String
Return String.Format("[{0},{1}]", nom, age)
End Function
' metodo init
Public Sub init()
Console.WriteLine("init personne {0}", Me.ToString)
End Sub
' metodo close
Public Sub close()
Console.WriteLine("destroy personne {0}", Me.ToString)
End Sub
End Class
La classe di test si trova in [NunitTestPersonne-1.vb]:
Imports System
Imports NUnit.Framework
<TestFixture()> _
Public Class NunitTestPersonne
' oggetto sottoposto a test
Private personne1 As Personne
<SetUp()> _
Public Sub init()
' si crea un'istanza di Persona
personne1 = New Personne
' log
Console.WriteLine("setup test")
End Sub
<Test()> _
Public Sub demo()
' log schermo
Console.WriteLine("début test")
' inizializzazione persona1
With personne1
.nom = "paul"
.age = 10
End With
' test
Assert.AreEqual("paul", personne1.nom)
Assert.AreEqual(10, personne1.age)
' log schermo
Console.WriteLine("fin test")
End Sub
<TearDown()> _
Public Sub destroy()
' monitoraggio
Console.WriteLine("teardown test")
End Sub
End Class
Ci sono diversi aspetti da sottolineare:
- i metodi sono dotati di attributi quali <Setup()>, <TearDown()>, ...
- affinché tali attributi vengano riconosciuti, è necessario che:
- il progetto faccia riferimento all'assembly [nunit.framework.dll]
- la classe di test importi lo spazio dei nomi [NUnit.Framework]
Il riferimento si ottiene facendo clic con il tasto destro del mouse su [References] nell’Esplora soluzioni:
 |  |
L'assembly [nunit.framework.dll] dovrebbe essere presente nell'elenco proposto se l'installazione di [Nunit] è andata a buon fine. È sufficiente fare doppio clic sull'assembly per aggiungerlo al progetto:
Una volta fatto ciò, la classe di test [NunitTestPersonne] deve importare lo spazio dei nomi [NUnit.Framework]:
Gli attributi della classe di test [NunitTestPersonne] devono quindi essere riconosciuti.
- l'attributo <Test()> indica un metodo da testare
- l'attributo <Setup()> indica il metodo da eseguire prima di ogni metodo sottoposto a test
- l'attributo <TearDown()> indica il metodo da eseguire dopo ogni metodo testato
- il metodo Assert.AreEqual consente di verificare l’uguaglianza tra due entités.Il; esistono numerosi altri metodi di tipo Assert.xx.
- L'utilità NUnit interrompe l'esecuzione di un metodo testato non appena un metodo [Assert] fallisce e visualizza un messaggio di errore. In caso contrario, visualizza un messaggio di esito positivo.
Configuriamo il nostro progetto in modo che generi un DLL:
Il DLL generato si chiamerà [nunit-demos-1.dll] e verrà inserito per impostazione predefinita nella cartella [bin] del progetto. Generiamo il nostro progetto. Nella cartella [bin] otteniamo:
Avviamo ora l’utilità di test grafico Nunit. Ricordiamo che si trova in <Nunit>\bin e che si chiama [nunit-gui.exe]. <Nunit> indica la cartella di installazione di [Nunit]. Si ottiene la seguente interfaccia:
Utilizziamo l’opzione di menu [File/Open] per caricare i file DLL e [nunit-demos-1.dll] del nostro progetto:
[Nunit] è in grado di rilevare automaticamente le classi di test presenti nel file DLL caricato. In questo caso, individua la classe [NunitTestPersonne]. Visualizza quindi tutti i metodi della classe che presentano l’attributo <Test()>. Il pulsante [Run] consente di avviare i test sull’oggetto selezionato. Se quest’ultimo è la classe [NunitTestPersonne], vengono testati tutti i metodi visualizzati. È possibile richiedere il test di un metodo specifico selezionandolo e richiedendone l’esecuzione tramite [Run]. Richiediamo l’esecuzione della classe:
Un test superato su un metodo è indicato da un punto verde accanto al metodo nella finestra di sinistra. Un test fallito è indicato da un punto rosso.
La finestra [Console.Out] a destra mostra le schermate generate dai metodi testati. In questo caso, abbiamo voluto seguire lo svolgimento di un test:
- la riga 1 mostra che il metodo dell'attributo <Setup()> viene eseguito prima del test
- le righe 2-3 sono generate dal metodo [demo] sottoposto a test (vedi il codice sopra)
- la riga 4 mostra che il metodo di attributo <TearDown()> viene eseguito dopo il test