Java Móvel

Nesse post, retirado do blog do Rafael Vianna, faremos uma pequena introdução aos tipos de teste, dando maior importância aos testes unitários e como eles podem ser utilizados em Java ME com framework JMUnit e a metodologia Test-Driven Development.
Testes automatizados são algo fundamental no desenvolvimento de software orientado a objetos. Eles permitem uma melhor evolução do software agregando confiança e qualidade ao produto final. No mundo Java SE e Java EE existem muitas ferramentas de testes. Quando olhamos para Java ME o número de ferramentas torna-se menor, devido tanto aos requisitos das aplicações quanto as restrições impostas pela própria API Java ME.

Diferentes tipos de testes em aplicações Java ME

Existem vários tipos de testes e eles variam de acordo com a aplicação e com os requisitos desejados pelo cliente. Em aplicações Java ME os principais tipos de teste são:
Testes de Usabilidade: tem foco na navegação entre as telas da aplicação e na maneira que os componentes visuais comunicam-se com o usuário.
Teste de performance e trafego na rede: testa se a aplicação funciona bem em redes que apresentam condições extremas. Aplicativos móveis devem funcionar de maneira satisfatória mesmo em redes muito congestionadas.
Testes do lado servidor: muitos aplicativos Java ME comunicação com servidores remotos. Para tais aplicativos testar as interfaces entre a aplicação que roda no dispositivo móvel e o servidor remoto é muito importante.
Testes unitários automatizados: estes é um dos mais importantes testes, seja em aplicativos móveis, Web ou Desktop. Ele feito durante o desenvolvimento do aplicativo, juntamente com o código-fonte. Geralmente esses testes são criados com algum framework da família xUnit (jUnit, nUnit, etc).

TDD

Test-Driven Development é uma maneira diferente de escrever software. Nela você primeiro escreve o teste e depois escreve o código a ser testado. O TDD está conseguindo cada vez mais adeptos graças a sua simplicidade e alto grau de qualidade do código ao durante todo o processo de desenvolvimento.
Algumas vantagens dessa abordagem são:
    * Simplicidade
    * Aumento da confiança no código
    * Ajuda na documentação
    * Falicita refatorações
O processo de criação no TDD é simples:
   1. Escreva um teste que falhe
   2. Faça o teste passar o mais rápido possível
   3. Refatore
   4. Faça o teste passar
   5. Refatore seus testes
   6. Faça os passos 1 a 5 para cada novo teste
   7. Repita todos os passos para cada novo método adicionado

Framworks para Testes Unitários

Para escrever testes unitários existem alguns frameworks, sendo o mais famosos deles o JUnit. Infelizmente o JUnit só pode ser utilizado em ambientes Java SE e Java EE, devido principalmente a algo que ele usa e é totalmente inexistente da API Java ME: reflexão. Isso ficou mais complicado depois do lançamento da versão 4 do JUnit, que agora também tem suporte a Annotations. Mesmo com essas barreiras, existem frameworks para testes unitários em Java ME, sendo os principais o JMUnit e o J2MEUnit.

O framework JMUnit

O JMUnit é um framework nos mesmos moldes do JUnit voltada para Java ME. Possui uma versão para configuração CLCD (1.0 e 1.1), é open-source e foi criado pelo brasileiro Bruno Silva.

JMUnit na prática

Chegou a hora de utilizar o JMUnit. Crie um novo MIDlet Project no Eclipse com o nome Java ME unit testes. Dentro da pasta src crie dois pacotes: model e jmunit.tests. A sua estrutura de diretórios deve ficar parecida com a da figura abaixo:

Vamos fazer algo bem simples somente para demonstração: uma classe que fará a conversão de temperatura de Celsius para Kelvin. Lembre-se que iremos utilizar TDD, então vamos escrever os testes primeiro.

Escrevendo os Testes

O JMUnit possui dois conceitos principais:
Test Case: classe onde os casos de testes são escritos.
Test Suite: classe onde os Test Cases são executados.
A primeira coisa que faremos é criar um Test Case para nossa classe de conversão. Para fazer isso siga os passos abaixo:
1 - Clique em o botão direito sobre o pacote jmunit.tests
2 - Selecione New - JMUnit Test Case

3 - Caso uma mensagem de alerta apareça na parte inferior do Wizard, clique onde diz Click here. Coloque o nome da classe de ConversionTest. Clique em Finish.

A classe gerada apresenta um construtor e um método:

public ConversionTest()
{
 super(0, "TemperatureConversionTest");
}

public void test(int testNumber) throws Throwable
{
 switch (testNumber)
 {
 }
}

O construtor possui dois parâmetros: o número de testes existentes no Test Case e o nome do Test Case. No método test nos passamos o número de testes que serão executados que servirá para o switch.

Agora vamos adicionar nossos testes. Irei seguir o padrão do JUnit onde cada método não terá retorno (void) e começa com o nome test seguido do nome do método que irá ser testado. O primeiro test será esse:

public void testcelsiusToKelvin() throws AssertionFailedException
{
 float result = TemperatureConversion.celsiusToKelvin(); // apresenta erro.
 assertEquals(0, result);
}

Para o teste acima funcionar você deve alterar o construtor da classe e o método test. Eles ficarão assim:

public ConversionTest()
{
 // Passe o número de testes no construtor, nesse caso o número 1
 super(1, "ConversionTest");
}

public void test(int testNumber) throws Throwable
{
 switch (testNumber)
 {
  // Também modificamos o "case". Lembre-se que o “case” em Java começa em 0.
  case 0: testcelsiusToKelvin(); break;
  default: break;
 }
}

Para rodar o teste é necessário criar um Test Suite. É bem simples criar um:

1 – Clique com o botão direito em cima da pacote “jmunit.tests”.

2 – Vá em New - JMUnit Test Suite.

3 – No Wizard que irá aparecer apenas clique em Finish

Agora siga os passos abaixo para rodar o teste:

1 – Clique com o botão direito em cima do Test Suite AllTestSuite.

2 – Vá em Run As - Emulated Java ME MIDlet.

3 – Surgirá uma janela de alerta do Eclipse. Clique no botão Proceed.

Rode o teste clicando em Test.

Opa! O testes falhou. Olhando o resultado do teste pode-se observar que a classe TemperatureConversion não existe. Realmente ela não existe ainda já estamos usando TDD. Escrevemos primeiro o teste e depois o código que irá ser testado, lembre-se disso.

Crie a classe:

1 – Utilize o Quick Fix do eclipse (Ctrl+1 ou clique no ‘x’ no começo da linha) e escolha a primeira opção: Create Class TemperatureConversion.

2 – Quando o Wizard aparacer, escolha o pacote model. Para isso clique no botão Browser, escolha o pacote model.

3 – Clique em Finish.

4 – Faça o mesmo processo para criar o método celsiusToKevin na classe TemperatureConversion . Não mude o conteúdo do método gerado.

Rodando o teste novamente ele irá passar. Isso é visto com a barrinha verde apresentada no MIDlet Emulator.

Agora vamos fazer mais um teste para nosso método. Vá na classe TemperatureConversionTest e adicione o sequinte método:

public void testcelsiusToKelvin(float c, float k) throws AssertionFailedException
{
 k = TemperatureConversion.celsiusToKelvin(c);
 assertEquals(298, k);
}

Não esqueça de mudar o construtor e o método test da classe:

public TemperatureConversionTest()
{
 super(2, "TemperatureConversionTest");
}

public void test(int testNumber) throws Throwable
{
 switch (testNumber)
        {
         case 0: testcelsiusToKelvin();break;
  case 1: testcelsiusToKelvin(25, 298);
  default: break;
 }
}

Rode a classe AllTestSuite novamente. Perceba que agora temos dois testes. Execute os testes.

Olhando o resultado dos testes percebemos que um deles passou e outro falhou. Vamos refatorar o método responsável pela conversão das temperaturas na classe TemperatureConversion colando a fórmula para conversão de Celsius para Kelvin, que é K = ºC + 273. Modifique o método para:

public static float celsiusToKelvin(float celsius)
{
 float kelvin = celsius + 273;
 return kelvin;
}

Parece tudo OK agora, não é? Só para garantir, rode os testes novamente.

Opa! Barrinha vermelha de novo. Mas o que será que está errado?

Vá na nossa classe de testes. Você esqueceu de refatorar o nosso primeiro método de testes. Modifique-o para:

public void testcelsiusToKelvin() throws AssertionFailedException
{
        // Agora é necessário passar um parâmatro para o método que nesse caso é 0 (zero).
 float result = TemperatureConversion.celsiusToKelvin(0);
 assertEquals(273, result);
}

Rode os testes e barrinha verde novamente aparecerá.

Conclusão

Testes unitários são algo de extrema importância no desenvolvimento de software. Como podemos ver, escrever testes unitários é algo bem simples e não há desculpas para não fazê-lo, seja em que ambiente for. No mundo Java ME existem outros frameworks para testes unitários, mas prefiro o JMUnit por sua simplicidade, por seguir o padrão xUnit e também por já estar integrado ao Eclipse Pulsar.

Java Móvel

Artigo: Configurando um Ambiente de Desenvolvimento Android

Testes Unitários em Java ME com JMUnit

Profissão Java 2010

Arquivo

Tags