8. Anexos

8.1. Onde encontrar o Spring?

O site principal do Spring é [http://www.springframework.org/]. Trata-se do site da versão Java. A versão .NET, atualmente em desenvolvimento (abril de 2005), encontra-se na URL [http://www.springframework.net/].

O site de download encontra-se 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, é necessário fazer sistematicamente duas coisas:

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

8.2. Onde 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 onde se encontra a versão gráfica de teste:

O que é interessante encontra-se na pasta [bin]:

A seta acima indica o utilitário gráfico de teste. A instalação também adicionou novos elementos ao repositório de assemblies do Visual Studio, que vamos explorar agora.

Vamos criar o seguinte projeto do Visual Studio:

A classe testada encontra-se em [Personne.vb]:

Public Class Personne

     ' campos privados
    Private _nom As String
    Private _age As Integer

     ' construtor por predefinição
    Public Sub New()
    End Sub

     ' propriedades associadas aos campos privados
    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

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

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

     ' método close
    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

     ' objeto testado
    Private personne1 As Personne

    <SetUp()> _
    Public Sub init()
         ' cria-se uma instância de Pessoa
        personne1 = New Personne
         ' registo
        Console.WriteLine("setup test")
    End Sub

    <Test()> _
    Public Sub demo()
         ' registo no ecrã
        Console.WriteLine("début test")
         ' inicialização de pessoa1
        With personne1
            .nom = "paul"
            .age = 10
        End With
         ' testes
        Assert.AreEqual("paul", personne1.nom)
        Assert.AreEqual(10, personne1.age)
         ' registo no ecrã
        Console.WriteLine("fin test")
    End Sub

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

End Class

Há vários aspetos a destacar:

os métodos possuem atributos como <Setup()>, <TearDown()>, ...
Para que esses atributos sejam reconhecidos, é necessário que:
- o projeto faça referência ao assembly [nunit.framework.dll]
- a classe de teste importe o espaço de nomes [NUnit.Framework]

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

O assembly [nunit.framework.dll] deve constar da lista apresentada se a instalação do [Nunit] tiver decorrido sem problemas. Basta clicar duas vezes no assembly para o adicionar ao projeto:

Feito isto, a classe de teste [NunitTestPersonne] deve importar o espaço de nomes [NUnit.Framework]:

Imports NUnit.Framework

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

o atributo <Test()> indica um método a testar
o atributo <Setup()> designa o método a executar antes de cada método testado
o atributo <TearDown()> designa o método a executar após cada método testado
o método Assert.AreEqual permite testar a igualdade entre dois entités.Il 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] falhar e apresenta uma mensagem de erro. Caso contrário, apresenta uma mensagem de sucesso.

Vamos configurar o nosso projeto para que gere um DLL:

O DLL gerado será denominado [nunit-demos-1.dll] e será colocado, por predefinição, na pasta [bin] do projeto. Vamos gerar o nosso projeto. Obtemos, na pasta [bin]:

Vamos agora executar o utilitário de teste gráfico Nunit. Recorde-se que este se encontra em <Nunit>\bin e que se chama [nunit-gui.exe]. <Nunit> designa a pasta de instalação do [Nunit]. Obtém-se a seguinte interface:

Utilizemos a opção de menu [File/Open] para carregar o DLL [nunit-demos-1.dll] do nosso projeto:

O [Nunit] é capaz de detetar automaticamente as classes de teste que se encontram no DLL carregado. Neste caso, encontra a classe [NunitTestPersonne]. Em seguida, apresenta todos os métodos da classe que possuem o atributo <Test()>. O botão [Run] permite executar os testes no objeto selecionado. Se este for a classe [NunitTestPersonne], todos os métodos apresentados são testados. É possível solicitar o teste de um método específico, selecionando-o e solicitando a sua execução através de [Run]. Vamos solicitar a execução da classe:

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

A janela [Console.Out], à direita, mostra as visualizações de ecrã produzidas pelos métodos testados. Aqui, quisemos acompanhar o desenrolar de um teste:

setup test
début test
fin test
teardown test

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] testado (ver o código acima)
a linha 4 mostra que o método de atributo <TearDown()> é executado após o teste