testes oo aspectos avançados em engenharia de software aula 6 fernanda campos dcc/ufjf
TRANSCRIPT
![Page 1: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/1.jpg)
Testes OO
Aspectos Avançados em Engenharia de Software
Aula 6Fernanda Campos
DCC/UFJF
![Page 2: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/2.jpg)
Teste de software A fase de teste, no processo de
desenvolvimento de software, tem papel crítico na garantia da qualidade.
Essa fase fornece subsídios para identificar problemas e mensurar a qualidade dos produtos.
A atividade de teste deve resultar em parâmetros que nos permitam avaliar o grau de confiança de um sistema.
![Page 3: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/3.jpg)
Teste de software
É necessário testar um sistema OO em uma variedade de níveis diferentes para descobrir erros que podem ocorrer à medida que classes colaboram umas com as outras e subsistemas se comunicam entre si.
Teste OO é estrategicamente similar ao teste de sistemas convencionais, mas é taticamente diferente.
![Page 4: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/4.jpg)
Teste de software O teste OO pode começar pela revisão dos modelos da
análise e do projeto. Uma vez gerado o código, começa uma série de testes para exercitar operações de classes e verificar se existem erros quando uma classe colabora com outra. À medida que as classes são integradas para formar um subsistema, o teste baseado em uso é aplicado. Finalmente, casos de uso são usados para descobrir erros em nível de validação do software.
Teste OO enfoca a seqüência de operações para exercitar os estados de uma classe.
![Page 5: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/5.jpg)
Para que testar? Qualidade: Código testado é mais confiável
• Como saber se o recurso funciona sem testar?
Coragem para mudar: De que adianta a OO isolar a interface da implementação se o programador tem medo de mudar a implementação?• Como saber se ainda funciona após refatoramento?
Saber quando o projeto está pronto. Testes são requisitos “executáveis”. Escreva-os antes. Quando todos rodarem 100%, o projeto está concluído!
![Page 6: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/6.jpg)
Todos sabem: testes devem ser escritos; Poucos o fazem, e por quê não ?
• Síndrome da pressa Isto cria um círculo vicioso
Como quebrar este ciclo: criando um ambiente simples de testes. Depois de fazer os primeiros testes, o hábito vem para ficar.
Problema com testes (e a solução)
menos testes
menos produtividademenos estabilidade
mais pressão
![Page 7: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/7.jpg)
Testar Depurar
Simplificando• Depurar - o que se faz quando se sabe que o
programa não funciona;
• Testar - tentativas sistemáticas de encontrar erros em programa que você “acha” que está funcionando.
“Testes podem mostrar a presença de erros, não a sua ausência (Dijkstra)”
![Page 8: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/8.jpg)
Teste de software Duas técnicas podem ser utilizadas para realizar teste de
software: teste funcional e teste estrutural. O teste funcional, também chamado teste de "caixa-
preta", testa o sistema do ponto de vista do usuário, isto é, não considera a estrutura interna ou a forma de implementação do sistema. Este é o único tipo de teste possível quando não se dispõe do código-fonte.
O teste estrutural, também chamado de teste de "caixa-branca", procura exercitar todas as partes do código-fonte de um sistema. Dessa forma, é necessário ter o código-fonte disponível, para controlar o que foi e o que não foi testado.
![Page 9: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/9.jpg)
Teste enquanto você escreve código
Se possível escreva os testes antes mesmo de escrever o código• uma das técnicas de XP
quanto antes for encontrado o erro melhor !!
![Page 10: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/10.jpg)
Técnicas básicas
Teste o código em seus limites; Teste de pré e pós condições; Uso de premissas (assert); Programe defensivamente; Use os códigos de erro.
![Page 11: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/11.jpg)
Teste o código em seus limites
Para cada pequeno trecho de código (um laço, ou if por exemplo) verifique o seu bom funcionamento;
Tente uma entrada vazia, um único item, um vetor cheio, etc.
![Page 12: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/12.jpg)
Testes sistemáticos Teste incrementalmente
• durante a construção do sistema• após testar dois pacotes independentemente teste se eles
funcionam juntos
Teste primeiro partes simples• tenha certeza que partes básicas funcionam antes de
prosseguir
• testes simples encontram erros simples
• teste as funções/métodos individualmente
![Page 13: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/13.jpg)
Testes Sistemáticos
Conheça as saídas esperadas• conheça a resposta certa
• para programas mais complexos valide a saída com exemplos conhecidos• compiladores - arquivos de teste;
• numéricos - exemplos conhecidos, características;
• gráficos - exemplos, não confie apenas nos seus olhos.
![Page 14: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/14.jpg)
Testes Sistemáticos
Verifique as propriedades invariantes• alguns programas mantém propriedades da
entrada• número de linhas
• tamanho da entrada
• freqüência de caracteres
![Page 15: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/15.jpg)
Testes Sistemáticos
Compare implementações independentes• os resultados devem ser os mesmos
• se forem diferentes pelo menos uma das implementações está incorreta
Cobertura dos testes• cada comando do programa deve ser
executado por algum teste
![Page 16: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/16.jpg)
Automação de testes
Testes manuais• tediosos, não confiáveis
Testes automatizados• devem ser facilmente executáveis
![Page 17: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/17.jpg)
Automação de testes
Teste de regressão automáticos• comparar a nova versão com a antiga
• verificar se os erros da versão antiga foram corrigidos
• verificar se novos erros não foram criados
![Page 18: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/18.jpg)
Automação de testes Crie testes autocontidos
• testes que contém suas próprias entradas e respectivas saídas esperadas
O que fazer quando um erro é encontrado?• se não foi encontrado por um teste
• faça um teste que o provoque
![Page 19: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/19.jpg)
Arcabouço de testes
As vezes para se testar um componente isoladamente é necessários criar um ambiente com características de onde este componente será executado
![Page 20: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/20.jpg)
Testes de estresse
Testar com grandes quantidades de dados• gerados automaticamente
• erros comuns:• overflow nos buffers de entrada, vetores e contadores
• Exemplo: ataques de segurança
![Page 21: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/21.jpg)
Tipos de teste
“white box”• testes feitos por quem conhece (escreveu) o
código
“black box”• testes sem conhecer o código
“usuários”• encontram novos erros pois usam o
programa de formas que não foram previstas
![Page 22: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/22.jpg)
Teste OO
O processo de teste de software OO apresenta algumas vantagens em relação ao procedural, entre as quais cita-se:• Métodos e interfaces de classes são explicitamente
definidos;
• Menos casos de testes para cobertura do software;
• Reutilização de casos de teste devido à presença da característica de herança.
![Page 23: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/23.jpg)
Teste OO
Existem desvantagens como:• A avaliação da corretude da classe é dificultada pela
presença do encapsulamento de informações;
• O gerenciamento do teste é dificultado pelos múltiplos pontos de entrada (métodos) de uma classe;
• As interações entre os objetos são expandidas pelo polimorfismo e pela ligação dinâmica.
![Page 24: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/24.jpg)
Tipos de testes em software OO
testes das classes
testes de interações testes de regressão teste do sistema e sub-sistemas teste de aceitação testes de implantação
![Page 25: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/25.jpg)
Análise de Riscos Análise de Riscos ajuda a planejar quais
testes devem ser feitos Um risco - ameaça ao sucesso de um projeto
riscos do gerenciamento do projeto testes não ajudam muito
riscos do negócio testes da funcionalidade
riscos técnicos testes de unidades, das classes, componentes, etc.
![Page 26: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/26.jpg)
Dimensões do Processo de Testes
Quem cria os testes? Os desenvolvedores? Uma equipe especializada em
testes? Ambos?
Quais partes são testadas? Todas? Nenhuma? Ou só as de alto risco?
Quando os testes serão realizados? Sempre? Rotineiramente? No final do projeto?
![Page 27: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/27.jpg)
Dimensões do Processo de Testes
Como será feito? Baseado no que o software faz ou em como o
software faz?
Os testadores conhecem a implementação ou só a interface?
Quanto de testes é o adequado?
![Page 28: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/28.jpg)
Papéis no Processo de Testes
Testador de classes Testador da Integração
testa as interações entre objetos
Testador do sistema conhece o domínio e é capaz de verificar a aplicação como um
todo
ponto de vista do usuário do sistema
Gerente do Processo de Testes coordena e escalona os testes e as pessoas
![Page 29: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/29.jpg)
Planejamento de Testes
Muitas vezes é esquecido ou não é considerado pelos gerentes de projeto
Atividades de planejamento: • Escalonamento das atividades de testes
• Estimativas de custo, tempo e pessoal necessário para realizar os testes
• Equipamento necessário
![Page 30: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/30.jpg)
Planejamento de Testes Atividades de planejamento:
• Definição do nível de cobertura: quanto maior, mais código será exigido.
métricas para avaliar eficácia de um conjunto de testes
• cobertura do código
• cobertura das pós-condições
• cobertura dos elementos do modelo
![Page 31: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/31.jpg)
Testes das Classes (unidades)
Uma maneira é o peer-review
• Errar é humano
Testes automatizados são melhores Testes automatizados devem cobrir
• alguns casos normais
• o maior número possível de casos limítrofes
![Page 32: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/32.jpg)
Testes das Interações
Objetos podem interagir de 4 formas diferentes:
• um objeto é passado como parâmetro para outro objeto numa chamada de método
• um objeto devolve uma referência para outro objeto numa chamada de método
• um método cria uma instância de outro objeto
• um método usa uma instância global de outra classe (normalmente evitado)
![Page 33: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/33.jpg)
Casos: Teste das interações
Chamadas de métodos 2 abordagens:
• Programação defensiva• O receptor verifica os parâmetros
• Programação por contrato• A mensagem é verificada antes do envio
![Page 34: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/34.jpg)
Casos: Teste das interações
Subclasses/superclasses
• Use o diagrama de classes para identificar quais testes de regressão devem ser realizados quando uma classe é alterada ou uma nova classe é criada.
• Execute os testes escritos para a superclasse mas agora usando a nova subclasse
• Para testar classes abstratas, somos obrigados a criar classes concretas só para testá-las
![Page 35: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/35.jpg)
O que são ferramentas para testes automáticos?
São programas que avaliam se outro programa funciona como esperado e retornam resposta do tipo "sim" ou "não“.Ex: um main() que cria um objeto de uma classe testada, chama seus métodos e avalia os resultados
Validam os requisitos de um sistema
![Page 36: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/36.jpg)
Testes Automáticos (self-checking)
Os testes devem verificar a si mesmos. A saída deve ser
• “OK” ou
• lista precisa das coisas que deram errado.
Quando os testes funcionam, sua saída deve ser apenas uma lista enxuta de “Oks”.
Ou um botão e uma luz verde e outra vermelha.
![Page 37: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/37.jpg)
O Testador Ideal
executar
Teste
verDetalhes
OK
Erro
![Page 38: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/38.jpg)
JUnit: O que é?
JUnit é um “framework” que facilita o desenvolvimento e execução de testes de unidade em código Java•Uma API para construir os testes
•Classes Test, TestCase, TestSuite, etc. oferecem a infraestrutura necessária para criar os testes.
•Métodos assertTrue( ), assertEquals( ), fail( ), etc. são usados para testar os resultados.
•Aplicações para executar testes (os TestRunners)•Rodam testes individuais e suites (conjuntos de
testes).
![Page 39: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/39.jpg)
JUnit: Para que serve? “Padrão” para testes de unidade em Java Desenvolvido por Kent Beck (o guru do XP) e Erich
Gamma (do GoF "Design Patterns") Facilita:
• A criação e execução automática de testes
• A apresentação dos resultados JUnit pode verificar se cada método de uma classe
funciona da forma esperada• Permite agrupar e rodar vários testes ao mesmo
tempo
• Na falha, mostra a causa em cada teste Serve de base para extensões
![Page 40: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/40.jpg)
CppUnit
CppUnit é a versão para C++ do JUnit (mas não é idêntico)
http://cppunit.sourceforge.net
A saída dos testes pode ser em XML ou em formato de texto para testes automáticos, e com interface visual para testes supervisionados
![Page 41: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/41.jpg)
JUnit: Como funciona
O TestRunner recebe uma subclasse de junit.framework.TestCase
Usa reflection para descobrir seus métodos
Para cada método testXXX(), executa:1. o método setUp()
2. o próprio método testXXX()3. o método tearDown()
O test case é instanciado para executar um método testXXX() de cada vez.
As alterações que ele fizer ao estado do objeto não afetarão os demais testes
Método pode terminar, falhar ou provocar exceção
TestCase
MyTestCase
setUp()
tearDown()
setUp()
testXXX( )
testYYY( )
tearDown()
![Page 42: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/42.jpg)
JMeter: Testes de Stress Uma ótima ferramenta open-source para testar oslimites de uma aplicação
• Simula carga pesada em servidor, rede ou objeto• Testa performance sob diferentes tipos de carga em
aplicações Web, servidores de FTP, objetos Java, bancos de dados, servlets, scripts em Perl, sistemas de arquivos, e outras aplicações (Java ou não)
• Gera gráficos com resultados para análise
JMeter pode ser usado para simular carga que cause falha em testes decorados com JUnitPerf
http://jakarta.apache.org/jmeter
![Page 43: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/43.jpg)
Dependência de código-fonte Problema: Como testar componente que depende do código de outros componentes? Classe-alvo não oferece o que testar:
Se houver tinta e se houver papel método void imprime( ) deve funcionar Como saber se há ou não tinta e papel?
public void testImprime( ) {Impressora imp = new Impressora();imp.imprime( ); // void!assert???(???);
}
temTinta()
Impressora
Bandeja
CartuchotestImprime() imprime()
temPapel()ImpressoraTest
![Page 44: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/44.jpg)
Stubs: objetos "impostores" É possível remover dependências de código-fonte
refatorando o código para usar interfaces
Agora B pode ser substituída por um stub• BStub está sob controle total de ATest (1)
• Em alguns casos, ATest pode implementar InterB (2)
![Page 45: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/45.jpg)
Dependência: solução usando stubs
Quando usar stubs•Dependência ainda não está pronta
•Dependências têm estado mutante, imprevisível ou estão indisponíveis durante o desenvolvimento•BDs, servidores de aplicação, servidores Web, hardware
![Page 46: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/46.jpg)
Dependências de servidores Usar stubs para simular serviços
• É preciso implementar classes que devolvam as respostas esperadas para diversas situações
• Complexidade pode não compensar investir no desenvolvimento
• Use soluções open-source prontas!• DBUnit: extensão do JUnit para testar aplicações JDBChttp://dbunit.sourceforge.net• JUnitEE: extensão do JUnit para testar aplicações J2EE http://junitee.sourceforge.net
Usar proxies para serviços reais• Testa a integração real do componente com seu ambiente• Solução open-source:
• Cactus: testa integração da aplicação com servlet containers
![Page 47: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/47.jpg)
Cactus: Testes de aplicações J2EE
Cactus é um framework open-source do projeto Jakarta para testar aplicações que utilizam componentes J2EE
•Componentes Web (Camada de Controle)
•Camada EJB (Model) e cliente (View): indiretamenteCactus estende o JUnit
Execução dos testes é realizada de forma idênticaTestCases são construídos herdando de uma subclasse de junit.framework.TestCase (Exemplo: ServletTestCase)
![Page 48: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/48.jpg)
Cactus: Testes de aplicações J2EE
Cactus testa a integração dos componentes Web com seus containers• Usa o próprio container como servidor e JUnit como cliente
• Uma cópia do Test Case é instanciada pelo container
• Outra cópia é instanciada pelo JUnit
• Comunicação é intermediada por um proxy (ServletRedirector, JSPRedirector ou FilterRedirector)• JUnit envia requisições via HTTP para proxy
• Proxy devolve resultado via HTTP e JUnit os mostra
ProxyClasse
de TesteClasses do Servidor
Cliente Servidor
Classe de Teste
(1) beginXXX()(2) (3)
(4) setUp()
(5) testXXX()
(6) tearDown()(8)
(9) endXXX()(7)
![Page 49: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/49.jpg)
Testes de interface em servidores Web Testar o funcionamento da aplicação do ponto de vista do
usuário• Verificar se uma página HTML ou XML contém
determinado texto ou determinado elemento• Verificar se resposta está de acordo com dados
passados na requisição: testes funcionais do tipo "caixa- preta"
Soluções (extensões do JUnit):• HttpUnit e ServletUnit:
•permitem testar dados de árvore DOM HTML gerada• JXWeb (combinação do JXUnit com HttpUnit)
•permite especificar os dados de teste em arquivos XML•arquivos de teste Java são gerados a partir do XML
• XMLUnit: extensão simples para testar árvores XML
![Page 50: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/50.jpg)
Dicas para fazer testes
Cheque os limites dos vetores• caso a linguagem não faça isto por você
• faça com que o tamanho dos vetores seja pequeno; ao invés de criar testes muito grandes
Faça funções de hashing constantes Crie versões de malloc que ocasionalmente falham Desligue todos os testes antes de lançar a versão
final
![Page 51: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/51.jpg)
Dicas para fazer testes
Inicialize os vetores e variáveis com um valor não nulo• ex: 0xDEADBEEF pode ser facilmente encontrado
Não continue a implementação de novas características se já foram encontrados erros
Teste em várias máquinas, compiladores e SOs
![Page 52: Testes OO Aspectos Avançados em Engenharia de Software Aula 6 Fernanda Campos DCC/UFJF](https://reader034.vdocuments.pub/reader034/viewer/2022052522/552fc11b497959413d8c98ce/html5/thumbnails/52.jpg)
Concluindo Testes proporcionam:
• Planejamento
• Refinamento do design
• Ritmo saudável
• Design simples
• Lançamentos pequenos Vale a pena investir tempo para desenvolver e
aperfeiçoar a prática constante de escrever testes automatizados
• mais produtividade, maior integração de equipes
• produtos de melhor qualidade, com prazo previsível
• menos stress, mais organização