Você pode ganhar um iPad 2 na promoção do Javafree

O Portal javafree.org inicia mais uma promoção para os usuários do fórum. Quem publicar mais posts válidos (perguntas ou respostas) entre 16/4 a 13/7 levará para casa um iPad 2 de 16GB!

Clique aqui e saiba mais.

Home > Artigos > Interfaces Gráficas >

Testando interfaces gráficas Swing com Jemmy

Publicado por Tutoriais Admin em 04/03/2010 - 16.723 visualizações

comentários: 1

por Kalecser Pasquali Kurtz
agradecimentos: Antonio Nodari e Rogério Tessari


A interface gráfica é a maneira com a qual a maioria dos programas se comunica com seus usuários, é comum que represente uma grande parcela do código e consequentemente dos defeitos da aplicação. Além disso ela é o meio instintivo para a realização de testes e definição de novas funcionalidades servindo como base para o entendimento entre usuários e desenvolvedores.

Devido às características intrinsecas das interfaces gráficas, dirigida a eventos e não lineares, elas são particularmente difíceis de serem testadas. Normalmente criam-se testes que são executados manualmente ou através de uma ferramenta de gravação e reprodução. A abordagem manual, porém, está sujeita a falhas humanas e é muito custosa, visto que a abordagem de gravação e reprodução tende a gerar scripts de testes repetidos, que são caros de manter, pois toda a vez que o sistema muda temos que mudar muitos testes que começam a quebrar.

Uma abordagem alternativa aos testes manuais e às ferramentas de gravação / reprodução são bibliotecas que permitem um acesso simples à interface através de código fonte permitindo que usemos os recursos da linguagem para isolar conceitos e fazer testes que se adaptem facilmente às mudanças.
Introduzindo o Jemmy

Jemmy é uma biblioteca de classes que disponibiliza uma API simples e intuitiva para acessar interfaces gráficas de usuário escritas em Swing, os testes são escritos como programas Java permitindo ao desenvolvedor utilizar todos os recursos da linguagem. Você pode obter o Jemmy em http://jemmy.netbeans.org/, ele é licenciado sob a Sun Public License (" SPL ").

O mecanismo de funcionamento do Jemmy se baseia no conceito de Operators. Um Operator é uma classe usada para localizar e manipular um componente swing. Segue um exemplo de uso de operators:
//Localiza um JFrame com o título Teste JFrameOperator testFrameOperator = new JFrameOperator("Teste"); //Localiza um JTextField dentro desse JFrame JTextFieldOperator textFieldOp = new JTextFieldOperator(testFrameOperator); //Insere um valor textFieldOp.setText("hello Jemmy");
listagem 1- Exemplo do uso de operators

Tela de amigos

ara demostrar melhor como funcionam os testes de interface gráfica com o Jemmy vamos usar uma aplicação simples que serve para cadastrar nomes de amigos, vejamos a sua tela principal.

Figura 1 Tela de amigos

O cenário de uso padrão dessa tela é:

• 1. Apertar o botão +
  
• 2. O amigo aparece na lista
  
• 3. Digitar o nome do campo de texto que está no canto inferior da tela.
  

Testando com o Jemmy

O primeiro passo é criar um TestCase do JUnit que exibe a tela no método setUp e descarta a tela no método tearDown, esse teste pode ser visto na listagem 2.


public class FriendScreenTests extends TestCase{     private FriendsScreen friendsScreen;     @Override     protected void setUp() throws Exception {         friendsScreen = new FriendsScreen(new FriendsModelImpl());         friendsScreen.setVisible(true);     }     @Override     protected void tearDown() throws Exception {         friendsScreen.setVisible(false);         friendsScreen.dispose();     } }
listagem 2- Testes da tela de amigos


Adicionando alguns amigos

O primeiro teste, listagem 3, consiste em adicionar dois amigos e conferir se eles aparecem na listagem. Para isso iremos criar um método de teste chamado testAddFriends na classe FriendScreenTests que executa os seguintes passos:

• 1. Abre a tela de amigos
  
• 2. Insere o nome 'Ernesto' no campo de texto
  
• 3. Aperta o botão '+'
  
• 4. Espera até que um elemento com o texto 'Ernesto' apareça na lista
  
• 5. Insere o nome 'Camilo' no campo de texto
  
• 6. Aperta o botão '+'
  
• 7. Espera até que um elemento com o texto 'Camilo' apareça na lista
  

public void testAddFriends() {     final String firstFriendName = "Ernesto";     final String secondFriendName = "Camilo";     JFrameOperator friendsScreenOp = new JFrameOperator(friendsScreen.getTitle());     addFriend(friendsScreenOp, firstFriendName);     checkIfFriendWasAdded(friendsScreenOp, firstFriendName, 0);     addFriend(friendsScreenOp, secondFriendName);     checkIfFriendWasAdded(friendsScreenOp, secondFriendName, 1); } private void addFriend(JFrameOperator friendsScreenOp, String friendName) {     JTextFieldOperator nameTextOp = new JTextFieldOperator(friendsScreenOp, 0);     nameTextOp.setText(friendName);     JButtonOperator addBtn = new JButtonOperator(friendsScreenOp, "+");     addBtn.pushNoBlock(); } private void checkIfFriendWasAdded(JFrameOperator friendsScreenOp, String friendName, int index) {     JListOperator friendsListOp = new JListOperator(friendsScreenOp);     friendsListOp.waitItem(friendName, index);
listagem 3 - Adicionando alguns amigos

Quanto ao código da listagem 3 é interessante notar que:

• Estamos usando o método pushNoBlock que irá apertar o botão em uma nova thread, assim no caso de o botão executar uma operação que coloca a thread atual em estado de espera como mostrar um JDialog o teste não para.
  
• Estamos usando o método waitItem que irá esperar até que o valor passado como parâmetro corresponda ao valor no índice desejado na lista ou até que o timeout seja atingido, caso o timeout seja atingido será lançada uma exceção que quebra o teste. O fato de termos que trabalhar com timeouts se deve a natureza do SWING que realiza operações em uma Thread diferente da principal e com base em uma fila de eventos.
  
• Para cada amigo que adicionamos já esperamos que ele esteja na lista, se não estivéssemos esperando teríamos resultados inesperados pois o clique do botão poderia ser processado apenas depois de já termos redefinido o valor do campo de texto fazendo o teste falhar.
  

Mais sobre Threads e Swing em:
http://java.sun.com/products/jfc/tsc/articles/threads/threads1.html

Mais sobre ações nonblocking em:
http://jemmy.netbeans.org/tutorial.html#nonblocking

Testando casos especiais

O segundo teste assegura que o sistema não deixa o usuário adicionar amigos com o nome em branco e exibe uma mensagem avisando dessa restrição, segue a lista de passos para executar o teste:

• 1. Abre a tela de amigos
  
• 2. Aperta o botão adicionar sem digitar nada no campo de texto
  
• 3. Uma caixa de diálogo com a mensagem "Para adicionar um amigo você deve digitar um nome" é exibida
  

public void testAddFriendWithoutName() {     JFrameOperator friendsScreenOp = new JFrameOperator(friendsScreen.getTitle());          final String blankName = "";     addFriend(friendsScreenOp, blankName);     JDialogOperator dialogOp = new JDialogOperator();     JLabelOperator labelMessageOp = new JLabelOperator(dialogOp);     assertEquals(FriendsScreen.BLANK_NAME_MESSAGE, labelMessageOp.getText()); }
listagem 4 - Quebrando regras de validação

Quanto ao código da listagem 3 é interessante reparar que se chamarmos o método doClick para apertar o botão ' + ' ao invés de pushNoBlock nosso teste ficaria parado esperando que a JDialog fosse encerrada.

Conclusão

Utilizar uma biblioteca de automatização de testes que permite um acesso à interface gráfica através de código fonte, como o Jemmy, ao invés de uma biblioteca de gravação reprodução traz algumas vantagens como:

• Não é preciso ficar repetindo código para tarefas corriqueiras como abrir a tela de Amigos, é possível colocar o código correspondente em um método e chamar quando necessário;
  
• Não é necessário aprender uma linguagem nova de script;
  
• Não necessita de uma ferramenta de gravação / reprodução;
  

Por outro lado testar usando uma biblioteca desse tipo faz com que os testes tenham que ser escritos pela equipe de desenvolvimento, desta forma acabam sendo menos intuitivos de se elaborar e tomam mais tempo para serem automatizados do que com uma ferramenta de gravação / reprodução. De qualquer forma parece ser positivo automatizar os testes de interface gráfica para que eles possam ser rodados com mais frequência e com menos possibilidade de falha, dando assim um retorno de maior qualidade para equipe de desenvolvimento e usuário.

Ver também:

http://www.marathontesting.com/
http://jemmy.netbeans.org/
http://jemmy.netbeans.org/RecordingVSCoding.html
http://www-128.ibm.com/developerworks/java/library/j-cq02277/index.html
http://java.sun.com/products/jfc/tsc/articles/threads/threads1.html


Código fonte

O código fonte pode ser encontrado em: http://javafree.org/dependencias/tutoriais/jemmy/Jemmy.zip

O código está definido como um projeto do Eclipse, para rodar você deve baixar a biblioteca jemmy.jar e colocar na pasta lib, a biblioteca jemmy.jar pode ser encontrada em:
http://jemmy.netbeans.org/downloads.html

Autor

Kalecser Pasquali Kurtz é um ciclista MTB e mochileiro que mora em Curitiba. Formado em tecnologia em processamento de dados pela Universidade de Caxias do Sul é um entusiasta de Extremme Programming e metodologias ágeis, trabalha com desenvolvimento de software desde 2001 e com Java desde 2003. Atualmente é funcionário da Objective Solutions.

Tópicos Relacionados


• Swing no XP  
• java desktop  
• Janelinhas ... Como fazer?  
• interface grafica + eclipse  
• receptores de eventos  
• Apresentando Model-View-Presenter ....  
• O que você "ainda" não sabe sobre Java Swing  
• Eclipse/JBuilder  
• subtraindo datas  
• Como criar uma aplicação GUI que converta temperaturas..  
• Interface eclipse?  
• Plug-In para Swing  
• Localizar palavras em JTextPane  
• Alguém poderia me indicar um bom livro para programação Java  
• Dúvida sobre implementação  

Home Sobre Anuncie

O JavaFree.org é uma comunidade java formada pela coolaboração dos desenvolvedores da tecnologia java. A publicação de artigos além de ajudar a comunidade java, ajuda a dar maior visibilidade para o autor. Contribua conosco.