8. Anexos

8.1. Onde posso encontrar o Spring?

O site principal do Spring é [http://www.springframework.org/]. Este é o site para a versão Java. A versão .NET, atualmente em desenvolvimento (abril de 2005), pode ser encontrada em [http://www.springframework.net/].

O site de download está em [SourceForge]:

Depois de descarregar o ficheiro zip acima, descompacte-o:

Neste documento, utilizámos apenas o conteúdo da pasta [bin]:

Num projeto do Visual Studio que utilize o Spring, deve sempre fazer duas coisas:

colocar os ficheiros acima na pasta [bin] do projeto
adicionar uma referência ao assembly [Spring.Core.dll] ao projeto

8.2. Onde pode encontrar o NUnit?

O site principal do NUnit é [http://www.nunit.org/]. A versão disponível em abril de 2005 é a 2.2.0:

Descarregue esta versão e instale-a. A instalação cria uma pasta que contém a interface gráfica de testes:

A parte interessante está na pasta [bin]:

A seta acima aponta para o utilitário de testes gráficos. A instalação também adicionou novos itens ao repositório de assemblies do Visual Studio, que iremos explorar agora.

Vamos criar o seguinte projeto do Visual Studio:

A classe que está a ser testada encontra-se em [Person.vb]:

Public Class Personne

    ' private fields
    Private _nom As String
    Private _age As Integer

    ' default builder
    Public Sub New()
    End Sub

    ' properties associated with private fields
    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

    ' identity chain
    Public Overrides Function tostring() As String
        Return String.Format("[{0},{1}]", nom, age)
    End Function

    ' init method
    Public Sub init()
        Console.WriteLine("init personne {0}", Me.ToString)
    End Sub

    ' close method
    Public Sub close()
        Console.WriteLine("destroy personne {0}", Me.ToString)
    End Sub

End Class

A classe de teste encontra-se em [NunitTestPersonne-1.vb]:

Imports System
Imports NUnit.Framework

<TestFixture()> _
 Public Class NunitTestPersonne

    ' object tested
    Private personne1 As Personne

    <SetUp()> _
    Public Sub init()
        ' create an instance of Person
        personne1 = New Personne
        ' log
        Console.WriteLine("setup test")
    End Sub

    <Test()> _
    Public Sub demo()
        ' log screen
        Console.WriteLine("début test")
        ' init person1
        With personne1
            .nom = "paul"
            .age = 10
        End With
        ' tests
        Assert.AreEqual("paul", personne1.nom)
        Assert.AreEqual(10, personne1.age)
        ' log screen
        Console.WriteLine("fin test")
    End Sub

    <TearDown()> _
    Public Sub destroy()
        ' follow-up
        Console.WriteLine("teardown test")
    End Sub

End Class

Várias coisas a ter em conta:

os métodos têm atributos atribuídos, tais como <Setup()>, <TearDown()>, ...
para que estes atributos sejam reconhecidos, é necessário que se verifique o seguinte:
- o projeto faz referência ao assembly [nunit.framework.dll]
- a classe de teste importa o namespace [NUnit.Framework]

A referência é adicionada clicando com o botão direito do rato em [Referências] no Explorador de Soluções:

O assembly [nunit.framework.dll] deverá constar na lista se a instalação do [NUnit] tiver sido bem-sucedida. Basta clicar duas vezes no assembly para o adicionar ao projeto:

Depois de fazer isso, a classe de teste [NunitTestPersonne] deve importar o namespace [NUnit.Framework]:

Imports NUnit.Framework

Os atributos da classe de teste [NunitTestPersonne] devem então ser reconhecidos.

O atributo <Test()> designa um método a ser testado
O atributo <Setup()> designa o método a ser executado antes de cada método a ser testado
O atributo <TearDown()> designa o método a ser executado após cada método a ser testado
O método Assert.AreEqual permite testar a igualdade entre duas entidades. Existem muitos outros métodos do tipo Assert.xx.
O utilitário NUnit interrompe a execução de um método testado assim que um método [Assert] falha e exibe uma mensagem de erro. Caso contrário, exibe uma mensagem de sucesso.

Vamos configurar o nosso projeto para gerar uma DLL:

A DLL gerada será denominada [nunit-demos-1.dll] e será colocada, por predefinição, na pasta [bin] do projeto. Vamos compilar o nosso projeto. Obtemos o seguinte na pasta [bin]:

Agora vamos iniciar o utilitário de testes gráficos do Nunit. Lembre-se de que ele se encontra em <Nunit>\bin e tem o nome [nunit-gui.exe]. <Nunit> refere-se à pasta de instalação [Nunit]. Obtemos a seguinte interface:

Vamos utilizar a opção de menu [Ficheiro/Abrir] para carregar a DLL [nunit-demos-1.dll] do nosso projeto:

O [Nunit] consegue detetar automaticamente as classes de teste contidas na DLL carregada. Aqui, encontra a classe [NunitTestPersonne]. Em seguida, apresenta todos os métodos da classe que possuem o atributo <Test()>. O botão [Run] permite-lhe executar os testes no objeto selecionado. Se for a classe [NunitTestPersonne], todos os métodos apresentados são testados. Pode testar um método específico selecionando-o e clicando em [Run]. Vamos executar a classe:

Um teste bem-sucedido num método é indicado por um ponto verde ao lado do método na janela da esquerda. Um teste falhado é indicado por um ponto vermelho.

A janela [Console.Out] à direita mostra a saída de ecrã produzida pelos métodos testados. Aqui, pretendíamos acompanhar o progresso de um teste:

setup test
test start
end of test
test teardown

A linha 1 mostra que o método de atributo <Setup()> é executado antes do teste
As linhas 2–3 são geradas pelo método [demo] que está a ser testado (ver o código acima)
A linha 4 mostra que o método do atributo <TearDown()> é executado após o teste