Quem diria que em tão pouco tempo aquela “caixa” que permitia a comunicação entre pessoas seria um dispositivo tão popular e indispensável ao ser humano se tornando utensílio pessoal como uma peça de roupa ou acessório.

A evolução tecnológica e a popularização destes dispositivos trouxeram uma outra revolução cultural fazendo o ser humano cada vez mais dependente da máquina. Um exemplo disto o número de telefone que antigamente era gravado na memória humana e hoje transferimos esta incumbência para os dispositivos celulares nos tornando cada vez mais dependentes desta onda digital

Graças a esta relação de dependência, os celulares passaram a ter um papel muito maior do que a sua proposta inicial suportando uma série de outros atributos como mp3 player, camera digital, vídeo, etc… se tornando cada vez mais um computador pessoal portátil.

Diante desta revolução surgem novas áreas de atuação gerando grandes oportunidades no segmento móbile. Estas oportunidades irão gerar uma demanda muito grande por soluções de software embarcado para estes dispositivos. A presença de ferramentas para desenvolvimento e principalmente para testes unitários são imprescindíveis para garantir a qualidade do que esta sendo desenvolvido.

O QUE É J2ME ?

A plataforma e linguagem JAVA é destinada a 3 grades grupos e mercado. A versão do Java mais conhecida é a J2SE (Java 2 Standat Edition) que define um conjunto de classes e uma maquina virtual (VM) para rodar qualquer tipo de aplicação JAVA em um computador. A outra versão é a J2EE (Java 2 Enterprise Edition) que define um outro conjunto de classes e especificações para desenvolvimento de aplicações JAVA em um ambiente corporativo.

A terceira família é o J2ME (Java 2 Micro Edition) (Figura 1) que é a versão do Java direcionado para os dispositivos portáteis como: celular, PDA ou até mesmo eletrodomésticos. O J2ME é mantido pela SUN Microsystem e seu desenvolvimento é orientado pelo JCP (Java Comunity Process) que é um consorcio de empresas que define as especificações que devem ser oficialmente implementadas para a plataforma.

Figura 1 – Versões do JAVA

A plataforma J2ME é dividida em 2 grupo chamados de profiles. Estes profiles são utilizados para classificar os dispositivos suportados pelo J2ME quanto a sua capacidade de processamento e utilização da memória. Os profiles conhecidos são:

(CLDC) Connected Limited Device Configuration – Este profile é destinado aos dispositivos com poucos recursos para processamento e uso de memória muito limitada. Aqui se enquadram os celulares e relógios.

(CDC) Connected Device Configuration – Este profile é destinado aos dispositivos com um poder maior de processamento e que podem prover mais memória. Neste grupo temos principalmente os PDA’s e Samrtphones. Este profile também é conhecido como personal profile é pode ser comparado com o J2SE na versão 1.2.

A interface com o usuário para cada profile e completamente diferente já que cada um é destinado a um grupo de dispositivos diferente. A CLDC possui objetos mais primitivos que interagem com o usuário em forma de menus e entrada de dados simples como em um celular convencional. Já a CDC possui recursos de interface mais avançados tendo a possibilidade de utilizar a biblioteca gráfica AWT para criação dos componentes visuais.

O J2ME utiliza como padrão a linguagem JAVA e seus principais objetos. Este objetos porem não são compatíveis com J2SE pois a sua implementação depende do profile que esta sendo utilizado, sendo assim por exemplo o objeto String do J2SE é diferente do objeto String do J2ME.

A VM (Maquina Virtual) do J2ME é definida através de uma especificação que define a sua forma de funcionamento. Os fabricantes implementam estas especificações para seus aparelhos seguindo os seus padrões de navegação, menu e botões. Por isto uma aplicação J2ME apesar de rodar em qualquer dispositivo com suporte a tecnologia possui uma aparência diferente para cada fabricante e muitas vezes modelo de celular.

TESTES UNITÁRIOS (UNITS TEST)

Os testes unitários são utilizados para testar a menor unidade de código possível de ser testada que são as funções. Esta técnica destina-se a testar todas as funções de uma aplicação levando em consideração os valores de entrada e os de saída, sem se prender a como este valores são processados. Os testes são codificados assim o sistema principal e a sua validação é feito através de asserções.

Os testes unitários devem ser planejados e codificados e da mesma forma como um programa, pode ser feito de várias formas. O que deve ser observado no momento de escrever um teste de unidade é a estratégia que será utilizada para validar o teste.

Deve se garantir que a estratégia utilizada é a mais aderente ao seu propósito. Pode-se utilizar também várias estratégias de testes fazendo com que os resultados sejam mais eficientes.

Os testes unitários fazem uso intenso de reflexão. Reflexão é uma técnica utilizada para explorar informações de um objeto sem conhecê-lo, ou seja, em tempo de execução. Através da reflexão a maioria dos Frameworks do mercado, automatiza o processo de fazer, rodar e dar os resultados dos testes unitários.

O uso de testes unitários é muito importante para diminuir os erros decorrentes da programação. A técnica é muito utilizada para programação utilizando métodos ágeis como o XP (Extreme Programing). O principal Framework do mercado foi escrito por Kent Beck, o próprio criado do XP.

No XP a utilização destes testes esta contido de forma direta em um das pratica e citado de forma indireta em várias outras pratica.

J2MEUNIT

O J2MEUnit é um Framework utilizado para fazer testes unitários em projetos desenvolvidos com J2ME. O Framework foi baseado no JUnit e possui as suas principais características. Como o J2MEUnit foi desenvolvido para J2ME, em comparação com o JUnit o mesmo possui uma série de limitações impostas pela tecnologia. A principal delas é o uso de reflexão.

J2ME não possui Reflaxão o que torna a construção dos testes unitários mais trabalhoso e manual, diferente do JUnit. Outro recurso que não podemos contar são as anotações e suporte de IDE’s.

Como não podemos contar com recursos como reflexão no J2MEUnit, é necessário utilizar um classe Runner que define quais classes contem os testes unitários que serão executados. Esta classe deve estar presente somente para iniciar os testes que são implementados em uma outras classes como descrito no trecho de código abaixo:


package takenami.lab2.agenda.testes;
import j2meunit.midletui.TestRunner;
public class AgendaTestRunner extends TestRunner { 
public AgendaTestRunner(){} 
 protected void startApp() {
  start(new String[] {
  "takenami.lab2.agenda.testes.AgendaTest"        
  });
 }
}


Os testes unitários devem ser implementados em classes que estendem TestCase. Ao estender desta classe automaticamente precisamos escrever os métodos: setUp()  e tearDown()  que são utilizados respectivamente para configurar um ambiente de execução no inicio e no final dos testes.Os métodos que serão testados devem ser implementados em um método Suite e adicionados a um objeto TestSuite, como descrito abaixo:

       
public Test suite() {//Cria o objeto com os testes que devem ser feitos
  TestSuite suite = new TestSuite("Testes de persistência da agenda");// teste de novo contato
  suite.addTest(new AgendaTest("Testando novo contato", new   TestMethod() {
            public void run(TestCase tc) throws Exception {
   ((AgendaTest) tc).testNovoContato();
            }
       }
  ));
     
  return suite;
}


Os métodos devem ser implementados dentro da mesma classe de teste e devem conter a estratégia que será utilizada para executar o teste:


//Testando um novo contato
public void testNovoContato() throws Exception {
    try {
     rs = RecordStore.openRecordStore("agenda_lab2", true);//Abre o banco de dados
       int numRegs1 = rs.getNumRecords(); //Verifica a quantidade de registros              
        rs.closeRecordStore(); //Fecha o banco de dados
         
      //Chama o objeto de negocio para inserir um novo contato
         agenda.novoContato("Paulo", "77777777");
         
         rs = RecordStore.openRecordStore("agenda_lab2", true); // Abre novamente o RecordStore
         int numRegs2 = rs.getNumRecords(); //Verifica a nova quantidade de registros no banco de dados
         rs.closeRecordStore(); //Fecha o banco de dados
         
         //A estrategia verifica se a qtd de registros anterior + 1 é igual a nova quantidade
         assertEquals("O total de registros deve ser acrescentado de 1",numRegs1+1,numRegs2);} catch (AssertionFailedError e) {
         System.out.println("FALHA");
 }  catch (Exception e) {
         System.out.println("ERRO:" + e.getClass().getName() + " - " + e.getMessage());
 }
}

CONCLUSÃO

A utilização do J2MEUnit para testes unitários em J2ME é muito importante visto que a pratica é indicada e extremamente necessária quando queremos desenvolver softwares mais estáveis. A limitação do Framework é uma barreira a ser rompida e o crescimento do mercado deve agir de forma direta sobre este fator, pois todos os dias são lançados novos dispositivos mais sofisticados com uma capacidade maior de processamento.Outro ponto que também deve ser melhorando é a integração com IDE’s disponíveis no mercado já que atualmente nenhuma das opções suportam de forma nativa o J2MEUnit. Isto também é um ponto que em breve deve ser resolvido já que a Eclipse Foudation que fornece o IDE EclipseME anunciou para a próxima versão a integração total com o produto.

Quem já conhece o JUnit não terá problemas com o J2MEUnit pois ele funciona de forma bastante similar. Para quem desenvolve em J2ME e não conhece é necessário aprender, pois certamente será uma opção viável para garantir em partes a qualidade do software.