A empresa de tecnologia anunciou um novo smartphone com câmera aprimorada, maior tela e bateria de longa duração. O dispositivo também possui processador mais rápido e armazenamento expansível. O novo modelo será lançado em outubro por um preço inicial de US$799.
QArentena do dia 22/08/2020
Diante de todas as fases que temos que testar, uma que muitas vezes deixamos de lado é a de Unit Testing. Ela é tão importante quanto as outras que já tem a aplicação integrada. Mas o que diferencia muito com relação as outras fases é que ela tem um feedback muito rápido que ajuda muito durante a fase de desenvolvimento.
O documento discute técnicas e estratégias para testes de software, enfatizando a importância de: 1) testar o código sistematicamente durante o desenvolvimento, 2) verificar limites e pré-condições, e 3) automatizar testes para validação contínua e prevenção de regressões.
O documento apresenta boas práticas de programação defensiva em Java, como: documentar o código, seguir convenções de nomes, tratar erros com exceções, usar asserções para validar entradas, liberar recursos alocados, dividir métodos com muitos parâmetros e testar o código. Também discute sobre precisão versus robustez e como depurar erros no código.
Atividades de Teste e Cobertura de Código em Javaaceiro
Erik Aceiro Antonio apresenta suas credenciais e experiência em testes de software e cobertura de código. Ele possui graduação em Ciência da Computação, mestrado em Engenharia Elétrica e está cursando doutorado em Ciência da Computação. Seu foco é no teste de software para sistemas embarcados críticos.
O documento resume os principais tópicos abordados na Aula 3 de Programação Orientada a Objetos com Java:
1) Operadores e expressões, incluindo operadores aritméticos, lógicos e condicionais;
2) Estruturas de decisão como if/else e operadores lógicos;
3) Estruturas de repetição como while, do-while e for para executar código de forma iterativa.
O documento discute técnicas de teste de software e exemplos de erros em sistemas. Aborda problemas comuns no teste, como falta de tempo e requisitos mudando, e casos reais de falhas como no foguete Ariane 5 e Challenger. Explica a importância de selecionar bons casos de teste para revelar erros.
O documento discute técnicas de teste de software, incluindo problemas comuns em testes e causas de falhas em sistemas. Exemplos históricos de falhas catastróficas em foguetes espaciais são apresentados para ilustrar a importância dos testes. Técnicas como teste funcional e teste estrutural são introduzidas como formas de selecionar casos de teste.
O documento discute a importância dos testes no desenvolvimento de software, mencionando três pontos principais:
1) Testes automatizados são necessários para evitar falhas futuras e garantir a qualidade do código.
2) É importante testar partes críticas do sistema que, caso falhem, podem ter grandes impactos.
3) Testes devem ser incorporados desde o início do desenvolvimento, por meio de metodologias como TDD.
QArentena do dia 22/08/2020
Diante de todas as fases que temos que testar, uma que muitas vezes deixamos de lado é a de Unit Testing. Ela é tão importante quanto as outras que já tem a aplicação integrada. Mas o que diferencia muito com relação as outras fases é que ela tem um feedback muito rápido que ajuda muito durante a fase de desenvolvimento.
O documento discute técnicas e estratégias para testes de software, enfatizando a importância de: 1) testar o código sistematicamente durante o desenvolvimento, 2) verificar limites e pré-condições, e 3) automatizar testes para validação contínua e prevenção de regressões.
O documento apresenta boas práticas de programação defensiva em Java, como: documentar o código, seguir convenções de nomes, tratar erros com exceções, usar asserções para validar entradas, liberar recursos alocados, dividir métodos com muitos parâmetros e testar o código. Também discute sobre precisão versus robustez e como depurar erros no código.
Atividades de Teste e Cobertura de Código em Javaaceiro
Erik Aceiro Antonio apresenta suas credenciais e experiência em testes de software e cobertura de código. Ele possui graduação em Ciência da Computação, mestrado em Engenharia Elétrica e está cursando doutorado em Ciência da Computação. Seu foco é no teste de software para sistemas embarcados críticos.
O documento resume os principais tópicos abordados na Aula 3 de Programação Orientada a Objetos com Java:
1) Operadores e expressões, incluindo operadores aritméticos, lógicos e condicionais;
2) Estruturas de decisão como if/else e operadores lógicos;
3) Estruturas de repetição como while, do-while e for para executar código de forma iterativa.
O documento discute técnicas de teste de software e exemplos de erros em sistemas. Aborda problemas comuns no teste, como falta de tempo e requisitos mudando, e casos reais de falhas como no foguete Ariane 5 e Challenger. Explica a importância de selecionar bons casos de teste para revelar erros.
O documento discute técnicas de teste de software, incluindo problemas comuns em testes e causas de falhas em sistemas. Exemplos históricos de falhas catastróficas em foguetes espaciais são apresentados para ilustrar a importância dos testes. Técnicas como teste funcional e teste estrutural são introduzidas como formas de selecionar casos de teste.
O documento discute a importância dos testes no desenvolvimento de software, mencionando três pontos principais:
1) Testes automatizados são necessários para evitar falhas futuras e garantir a qualidade do código.
2) É importante testar partes críticas do sistema que, caso falhem, podem ter grandes impactos.
3) Testes devem ser incorporados desde o início do desenvolvimento, por meio de metodologias como TDD.
Este documento fornece uma breve introdução às técnicas de teste de software, descrevendo conceitos como:
- Casos de teste, que especificam entradas e saídas esperadas para testar o programa.
- Critérios de teste, como particionamento de equivalência e análise de valor limite, que guiam a geração sistemática de casos de teste.
- Teste funcional e estrutural, que se baseiam respectivamente na especificação e implementação do software.
O documento discute testes de software, introduzindo conceitos como testes formais, tipos de testes (unidade, integração, sistema, aceitação, regressão), aspectos do comportamento testado (funcionalidade, performance, robustez, confiabilidade, disponibilidade) e estratégias de teste (caixa-preta, white-box, grey-box). Também aborda o processo de teste, automação, utilização de testes e a relação entre testes e métodos formais.
Apresentação no TDC2013 - Florianópolis da trilha Mobile e Embedded (25/05/2013). Apresenta algumas dicas, técnicas e sugestões de como melhorar o processamento e uso de memória no código.
Este documento fornece uma introdução sobre testes de software, com foco nos testes funcionais em times ágeis. Apresenta conceitos como qualidade, garantia da qualidade versus controle da qualidade, níveis e tipos de teste, técnicas de teste como análise de valor limite, particionamento por equivalência e tabelas de decisão. Também discute validação versus verificação, desenho de testes, cenários e casos de teste. Por fim, aborda técnicas ágeis como teste exploratório.
O documento descreve um curso sobre testes automatizados em Python. O curso aborda:
1) Testes unitários, de integração e funcionais com foco nos fundamentos de testes automatizados;
2) A prática do uso de testes automatizados no desenvolvimento guiado por testes (TDD);
3) As vantagens da abordagem TDD no curto e longo prazo e dos testes automatizados no longo prazo.
O documento discute várias técnicas de teste de software, incluindo:
1) Partição de equivalência - Uma técnica para dividir entradas em grupos com comportamento similar e testar um caso de cada grupo.
2) Análise de valor limite - Testa valores próximos aos limites de cada partiçao para verificar possíveis defeitos nessas regiões.
3) Tabela de decisão - Usa regras lógicas para gerar combinações de entrada para teste.
4) Teste de transição de estados - Testa um sistema modelado como máqu
O documento discute conceitos básicos de lógica de programação, incluindo ferramentas como Portugol e Scratch, estruturas de decisão e repetição, variáveis, constantes e operadores. Explica como algoritmos usam lógica para resolver problemas através de sequências de instruções.
O documento descreve a história inicial do desenvolvimento do Java. Em 1990, a ideia era criar um dispositivo wireless sensível ao toque para controlar diversos dispositivos, mas o projeto não foi adiante. Em 1995, a equipe decidiu criar um navegador capaz de rodar a linguagem Java, chamado de HotJava. Posteriormente, o Java ganhou popularidade por sua portabilidade, sendo usado em diversas áreas como desenvolvimento web, sistemas Android e desktop.
O documento discute vários tópicos relacionados a testes de software, incluindo:
1) Condições de teste e casos de teste;
2) Estruturas para casos de teste;
3) Critérios de qualidade para casos de teste;
4) Técnicas de modelagem de teste como particionamento de equivalência e análise de valor limite.
Tecnicas Para Planejamento E Execucao De Testes De Softwaremarthahuback
O documento discute técnicas para mapeamento de cenários de teste e técnicas de teste de caixa preta e caixa branca. Ele explica como mapear cenários de teste com foco no negócio e nos usuários, e como cenários de teste devem ser objetivos, reduzir incertezas e encontrar erros. Também descreve técnicas de teste de caixa preta como análise de valor limite, particionamento por equivalência e transição de estados, e técnicas de caixa branca como teste unitário e TDD.
Padrões para Desenvolvimento de Software Guiado por TestesEverton Rodrigues
Este documento fornece padrões e técnicas para desenvolvimento de software guiado por testes, incluindo escrever testes primeiro, usar dados de teste realistas, e isolar testes. Os padrões ajudam a responder perguntas como quanto testar e como escolher o que testar.
O documento discute técnicas de teste baseadas na estrutura do código, como cobertura de comandos, decisões e caminhos. Ele explica o que é cobertura de teste e como medir a cobertura de comandos e decisões. Além disso, aborda outras técnicas como cobertura de desvio, LCSAJ e cobertura de caminho, bem como técnicas baseadas na experiência como suposição de erros e teste exploratório.
O documento apresenta um guia rápido de referência sobre variáveis, tipos de dados, operadores e fluxos de controle na linguagem Java, incluindo a declaração e inicialização de variáveis, tipos primitivos, constantes, operadores aritméticos, relacionais e lógicos. Também aborda comentários, strings, entrada e saída de dados, e convenções de codificação.
O documento discute testes de software, incluindo:
1) Os objetivos dos testes de software e os tipos principais como testes unitários e de integração.
2) Exemplos de como escrever testes unitários usando arranjos, ações e afirmações.
3) A importância de testar os próprios testes através de técnicas como teste de mutação.
Este documento discute a importância dos testes no desenvolvimento de software, abordando as fases dos testes e os tipos de testes utilizados em cada fase. Descreve testes estruturais e funcionais, assim como as quatro fases de testes: teste de unidade, integração, bottom-up e top-down.
O documento descreve operadores e comandos de controle de fluxo em Java, incluindo operadores unários, aritméticos, de atribuição, comparação, lógicos e instanceof. Também explica comandos condicionais como if/else e switch e comandos de repetição como while, do/while e for, além de break e continue.
O documento discute técnicas de teste de software, como cobertura de testes e partições de domínio. Explica como medir a cobertura de funções, linhas e ramos de código para identificar partes não testadas. Também mostra um exemplo de função com 100% de cobertura que ainda continha um bug, enfatizando que cobertura completa não significa ausência de erros.
O documento discute técnicas de teste de software e métricas de cobertura de testes. Aborda os conceitos de cobertura de comandos, linhas e funções e como essas métricas podem identificar partes do código que não foram testadas. Também apresenta exemplos de implementação de árvores binárias e splay trees para ilustrar como a cobertura de testes pode ser aplicada.
O documento discute princípios de código limpo, incluindo: 1) tratar erros com exceções em vez de códigos de retorno; 2) limitar dependências de código de terceiros; 3) escrever testes de unidade limpos e automatizados para guiar o desenvolvimento. Ele também aborda tópicos como classes pequenas com responsabilidade única, separação de construção e uso de sistemas, e refinamento contínuo aplicando boas práticas.
O documento apresenta uma introdução ao teste de software, discutindo sua história, objetivos, processos, técnicas e ferramentas. Inclui tópicos como planejamento, projeto, execução e entrega de testes, níveis de teste, técnicas como caixa preta e branca e critérios como análise de valor limite e tabela de decisão. Por fim, fornece referências sobre o tema.
O documento discute automação de testes de software. Ele explica que a automação de testes envolve codificar casos de teste para serem executados automaticamente por máquinas. Também discute quando a automação de testes é apropriada versus testes manuais, e que uma combinação de ambos é frequentemente a abordagem mais eficaz.
O documento apresenta uma disciplina sobre automatização de testes. Ele discute os problemas do processo de teste manual, ferramentas de teste como TestLink e Mantis, e como migrar casos de teste de um processo manual para essas ferramentas.
Este documento fornece uma breve introdução às técnicas de teste de software, descrevendo conceitos como:
- Casos de teste, que especificam entradas e saídas esperadas para testar o programa.
- Critérios de teste, como particionamento de equivalência e análise de valor limite, que guiam a geração sistemática de casos de teste.
- Teste funcional e estrutural, que se baseiam respectivamente na especificação e implementação do software.
O documento discute testes de software, introduzindo conceitos como testes formais, tipos de testes (unidade, integração, sistema, aceitação, regressão), aspectos do comportamento testado (funcionalidade, performance, robustez, confiabilidade, disponibilidade) e estratégias de teste (caixa-preta, white-box, grey-box). Também aborda o processo de teste, automação, utilização de testes e a relação entre testes e métodos formais.
Apresentação no TDC2013 - Florianópolis da trilha Mobile e Embedded (25/05/2013). Apresenta algumas dicas, técnicas e sugestões de como melhorar o processamento e uso de memória no código.
Este documento fornece uma introdução sobre testes de software, com foco nos testes funcionais em times ágeis. Apresenta conceitos como qualidade, garantia da qualidade versus controle da qualidade, níveis e tipos de teste, técnicas de teste como análise de valor limite, particionamento por equivalência e tabelas de decisão. Também discute validação versus verificação, desenho de testes, cenários e casos de teste. Por fim, aborda técnicas ágeis como teste exploratório.
O documento descreve um curso sobre testes automatizados em Python. O curso aborda:
1) Testes unitários, de integração e funcionais com foco nos fundamentos de testes automatizados;
2) A prática do uso de testes automatizados no desenvolvimento guiado por testes (TDD);
3) As vantagens da abordagem TDD no curto e longo prazo e dos testes automatizados no longo prazo.
O documento discute várias técnicas de teste de software, incluindo:
1) Partição de equivalência - Uma técnica para dividir entradas em grupos com comportamento similar e testar um caso de cada grupo.
2) Análise de valor limite - Testa valores próximos aos limites de cada partiçao para verificar possíveis defeitos nessas regiões.
3) Tabela de decisão - Usa regras lógicas para gerar combinações de entrada para teste.
4) Teste de transição de estados - Testa um sistema modelado como máqu
O documento discute conceitos básicos de lógica de programação, incluindo ferramentas como Portugol e Scratch, estruturas de decisão e repetição, variáveis, constantes e operadores. Explica como algoritmos usam lógica para resolver problemas através de sequências de instruções.
O documento descreve a história inicial do desenvolvimento do Java. Em 1990, a ideia era criar um dispositivo wireless sensível ao toque para controlar diversos dispositivos, mas o projeto não foi adiante. Em 1995, a equipe decidiu criar um navegador capaz de rodar a linguagem Java, chamado de HotJava. Posteriormente, o Java ganhou popularidade por sua portabilidade, sendo usado em diversas áreas como desenvolvimento web, sistemas Android e desktop.
O documento discute vários tópicos relacionados a testes de software, incluindo:
1) Condições de teste e casos de teste;
2) Estruturas para casos de teste;
3) Critérios de qualidade para casos de teste;
4) Técnicas de modelagem de teste como particionamento de equivalência e análise de valor limite.
Tecnicas Para Planejamento E Execucao De Testes De Softwaremarthahuback
O documento discute técnicas para mapeamento de cenários de teste e técnicas de teste de caixa preta e caixa branca. Ele explica como mapear cenários de teste com foco no negócio e nos usuários, e como cenários de teste devem ser objetivos, reduzir incertezas e encontrar erros. Também descreve técnicas de teste de caixa preta como análise de valor limite, particionamento por equivalência e transição de estados, e técnicas de caixa branca como teste unitário e TDD.
Padrões para Desenvolvimento de Software Guiado por TestesEverton Rodrigues
Este documento fornece padrões e técnicas para desenvolvimento de software guiado por testes, incluindo escrever testes primeiro, usar dados de teste realistas, e isolar testes. Os padrões ajudam a responder perguntas como quanto testar e como escolher o que testar.
O documento discute técnicas de teste baseadas na estrutura do código, como cobertura de comandos, decisões e caminhos. Ele explica o que é cobertura de teste e como medir a cobertura de comandos e decisões. Além disso, aborda outras técnicas como cobertura de desvio, LCSAJ e cobertura de caminho, bem como técnicas baseadas na experiência como suposição de erros e teste exploratório.
O documento apresenta um guia rápido de referência sobre variáveis, tipos de dados, operadores e fluxos de controle na linguagem Java, incluindo a declaração e inicialização de variáveis, tipos primitivos, constantes, operadores aritméticos, relacionais e lógicos. Também aborda comentários, strings, entrada e saída de dados, e convenções de codificação.
O documento discute testes de software, incluindo:
1) Os objetivos dos testes de software e os tipos principais como testes unitários e de integração.
2) Exemplos de como escrever testes unitários usando arranjos, ações e afirmações.
3) A importância de testar os próprios testes através de técnicas como teste de mutação.
Este documento discute a importância dos testes no desenvolvimento de software, abordando as fases dos testes e os tipos de testes utilizados em cada fase. Descreve testes estruturais e funcionais, assim como as quatro fases de testes: teste de unidade, integração, bottom-up e top-down.
O documento descreve operadores e comandos de controle de fluxo em Java, incluindo operadores unários, aritméticos, de atribuição, comparação, lógicos e instanceof. Também explica comandos condicionais como if/else e switch e comandos de repetição como while, do/while e for, além de break e continue.
O documento discute técnicas de teste de software, como cobertura de testes e partições de domínio. Explica como medir a cobertura de funções, linhas e ramos de código para identificar partes não testadas. Também mostra um exemplo de função com 100% de cobertura que ainda continha um bug, enfatizando que cobertura completa não significa ausência de erros.
O documento discute técnicas de teste de software e métricas de cobertura de testes. Aborda os conceitos de cobertura de comandos, linhas e funções e como essas métricas podem identificar partes do código que não foram testadas. Também apresenta exemplos de implementação de árvores binárias e splay trees para ilustrar como a cobertura de testes pode ser aplicada.
O documento discute princípios de código limpo, incluindo: 1) tratar erros com exceções em vez de códigos de retorno; 2) limitar dependências de código de terceiros; 3) escrever testes de unidade limpos e automatizados para guiar o desenvolvimento. Ele também aborda tópicos como classes pequenas com responsabilidade única, separação de construção e uso de sistemas, e refinamento contínuo aplicando boas práticas.
O documento apresenta uma introdução ao teste de software, discutindo sua história, objetivos, processos, técnicas e ferramentas. Inclui tópicos como planejamento, projeto, execução e entrega de testes, níveis de teste, técnicas como caixa preta e branca e critérios como análise de valor limite e tabela de decisão. Por fim, fornece referências sobre o tema.
Semelhante a GOTEST-Aula4-Automacao-Parte1.pdf (20)
O documento discute automação de testes de software. Ele explica que a automação de testes envolve codificar casos de teste para serem executados automaticamente por máquinas. Também discute quando a automação de testes é apropriada versus testes manuais, e que uma combinação de ambos é frequentemente a abordagem mais eficaz.
O documento apresenta uma disciplina sobre automatização de testes. Ele discute os problemas do processo de teste manual, ferramentas de teste como TestLink e Mantis, e como migrar casos de teste de um processo manual para essas ferramentas.
O documento discute o papel de engenheiro de testes de software. Ele descreve os objetivos de testar software para fornecer evidências e identificar problemas, os vários papéis de um engenheiro de testes, as habilidades necessárias e certificações e eventos nessa área.
O documento apresenta o processo de testes, incluindo planejamento, especificação, execução, análise e controle. Detalha as etapas de planejamento dos testes, especificação dos casos de teste, execução dos testes manuais ou automatizados, e análise dos resultados obtidos.
O documento fornece diretrizes sobre execução de testes e análise de resultados, incluindo preparação, execução dos testes, registro de defeitos, relatórios e análise. Ele discute a importância da comunicação e da classificação correta dos defeitos para garantir que os problemas sejam corrigidos.
O documento discute técnicas e conceitos importantes para projetos de teste de software, incluindo a escrita de casos de teste baseados em requisitos e documentação, técnicas estáticas e dinâmicas de teste, particionamento de classes de equivalência, valor limite, cenários de casos de uso, objetivos e procedimentos de casos de teste, seleção de casos de teste e matrizes de rastreabilidade.
O documento apresenta os principais conceitos e artefatos relacionados ao planejamento de testes de software, incluindo a visão geral do processo de testes, os principais artefatos como o plano de testes e projeto de testes, e os detalhes que devem constar no plano de testes como escopo, estratégias, recursos e cronograma.
1. MAIO 2009
MAIO 2009
Jorge Oliveira
jorge@gotest.biz
http://www.applabs.com/uploads/tool.jpg
Introdução a
Automação de Testes
Introdução a
Automação de Testes
2. AGENDA
AGENDA
JUnit
Recapitulando alguns conceitos ...
Driver, Stub, Mock
Em que ordem testar?
Adequação
Particionamento
Testes Caixa-Branca
Cobertura de Código
Ant
TDD
3. JUnit 4
JUnit 4
Uma classe JUnit 4 é uma classe qualquer!!
Uma classe JUnit 4 é uma classe qualquer!!
Criando caso de testes:
Criando Asserts:
4. JUnit 4
JUnit 4
Uma classe JUnit 4 é uma classe qualquer!!
Uma classe JUnit 4 é uma classe qualquer!!
Métodos de inicialização e limpeza de Casos de Testes
Métodos de inicialização e limpeza de Classes de Testes
Testando Exceções:
8. Recapitulando alguns conceitos ...
Recapitulando alguns conceitos ...
Unit
Test
Unit
Test
Unit
Test
Integration
Test
Integration
Test
System Test
9. Driver, Stub
Driver, Stub
Componente 1 Componente 2
Componente 2
Driver
Stub
• Driver exercita o módulo que está
sendo Testado
• Stub complementa o módulo que
está sendo testado
14. Adequação
Adequação
Quando parar de testar??
Teste é incompleto!!!!
Testar tudo normalmente é impossível.
É necessário uma medida para indicar a completude
de uma suíte de teste.
Critérios de Adequação:
Suíte 1
• Requisito A deve ser executado
• Requisito B deve estar em Fluxo de Exceção 1
Suíte 2
• Requisito C deve ser executado
• Requisito A e B deve estar em Fluxo de
Exceção 1 e 3, respectivamente
15. Particionamento
Particionamento
Espaço Amostral para entradas normalmente
tende ao infinito!
Precisamos agrupar valores de
entrada que representam resultados
esperados teoricamente
semelhantes!!!!
Classes de Equivalência
16. Particionamento
Particionamento
Considerando o seguinte método:
E o seguinte requisito:
“Crianças de até 5 anos não pagam. Idosos a partir de 65 anos
pagam 30% do valor e estudantes pagam 50% do valor total. Os
descontos não podem ser cumulativos”
Classes de Equiv. Estudante (A) Não-Estudante (B)
Idade <= 5 anos (X)
5 < Idade < 65 anos (Y)
Idade >= 65 anos (Z)
17. Particionamento
Particionamento
Combinatorial
Combinação de todas as classes de equivalência em produto cartesiano.
{(A,X), (A,Y), (A,Z), (B,X), (B,Y), (B,Z)}
Pairwise
A maior parte dos bugs provém de apenas um dos parâmetros ou de um par deles.
Pairwise testa todos os possíveis pares de valores
Exemplo: Num sistema de custos, um usuário tem que escolher uma operadora
(TIM, Vivo ou Oi), um plano de minutos (30, 60 ou 90 minutos) e um plano de
mensagens (10, 50 ou 100 mensagens).
18. Particionamento
Particionamento
Pairwise (Cont.)
Particionamento combinatorial geraria 3 x 3 x 3 = 27 combinações
Particionamento pairwise gerou apenas 15 combinações
Curiosidade: Assumamos um programa que contém 75 parâmetros binários. Um
particionamento combinatorial geraria 2 elevado a 75 combinações ... ou seja:
37,778,931,862,957,161,709,568. Utilizando pairwise, é possível conseguir uma
excelente cobertura com apenas 28 combinações.
Catalog Based
Baseado em especificações.
Uma documentação explicitando todas as condições (aninhadas ou não) para cada
entrada deve ser disponibilizada.
Esse método é o mais efetivo e mais trabalhoso.
19. Testes de Caixa Branca
Testes de Caixa Branca
Teste também chamado
de Teste Estrutural, uma
vez que foca na estrutura
do código;
Critérios de adequação
baseados no código.
Semelhante a um grafo
20. Testes de Caixa Branca
Testes de Caixa Branca
expr0;
while (condA){
if (condB){
expr1; expr2;
}
expr3;
}
expr4;
expr0
condA
expr1;
expr2;
expr3
condB
expr4
Teste = Seqüência de Nós!!
Teste = Seqüência de Nós!!
21. Testes de Caixa Branca
Testes de Caixa Branca
expr0
condA
expr1;
expr2;
expr3
condB
expr4
b
b
c
c
a
a
f
f
d
d
e
e
t0
t1 t6
t2
t3
t4
t5
22. Testes de Caixa Branca
Testes de Caixa Branca
b
b
c
c
a
a
f
f
d
d
e
e
t0
t1 t6
t2
t3
t4
t5
• Adequação por Nó
• Adequação por Transição
• Adequação por Caminho
• Adequação Estrutural
Statement
Basic-Block
Branch
Basic Condition
Compound Condition
MC/DC
Path
…
23. Cobertura de Código
Cobertura de Código
Cobertura de código ou Adequação Estrutural
são métricas que indicam o quão forte é o seu
projeto de testes
Cobertura de código ou Adequação Estrutural
são métricas que indicam o quão forte é o seu
projeto de testes
24. Cobertura de Código
Cobertura de Código
JCoverage
- Ferramenta sob licença GPL
- Relatórios de classes, métodos e linhas
- Pouca integração com outras ferramentas
Emma
- Ferramenta open source mais utilizada
- Ferramenta mais rápida
- Integração com Eclipse
- Relatorios de cobertura por instrução, linha, bloco e método
Clover
- Líder do mercado
- Relatório de efetividade de teste
- Diversos tipos de cobertura
- Otimizador de testes
- Relatórios mais completos
Outros: GroboUtils, Hansel, NoUnit
25. Cobertura de Código
Cobertura de Código
1. Cobertura por Expressão ou por Linha
(Statement Coverage ou Line Coverage)
- Métrica que representa a porcentagem de linhas de código executadas
- Muito simples de ser implementada
- Mais utilizada
- Não testa a lógica da aplicação
2. Cobertura por Blocos Básicos
(Basic Block Coverage)
- Métrica que representa a porcentagem de blocos básicos executados
- Bloco básico é tudo que está entre chaves
- Não testa a lógica da aplicação
26. Cobertura de Código
Cobertura de Código
3. Cobertura por Decisão ou por Galho
(Decision Coverage ou Branch Coverage)
- Métrica que representa a porcentagem de condicionais (como “if” ou “while”),
executadas como verdadeiras e falsas
- Relativamente simples de ser implementada
- Não se importa sobre como as expressões condicionais chegaram a um valor
4. Cobertura por Condição
(Condition Coverage)
- Métrica que representa a porcentagem de expressões (tudo que está separado
por um OR ou AND, por exemplo) de condicionais (como “if” ou “while”),
executadas como verdadeiras e falsas
- Extremamente complexa (dependendo da aplicação)
- Pode ser pouco efetiva uma vez que não se importa com o resultado da macro
expressão (condição)
27. Cobertura de Código
Cobertura de Código
5. Cobertura por Condições Múltiplas
(Multiple Condition Coverage)
- Métrica que representa a porcentagem de expressões (tudo que está separado
por um OR ou AND, por exemplo) de condicionais (como “if” ou “while”),
executadas como verdadeiras e falsas, bem como a própria condicional que são
executadas
- Extremamente extensa (dependendo da aplicação)
- É uma combinação entre a cobertura por decisão e cobertura por condição
- É muito efetiva
6. Cobertura por Caminhos
(Path Coverage)
- Métrica que representa a porcentagem de diferentes caminhos da aplicação
que são executados
- Eventualmente existem caminhos impossíveis
- Alguns loops podem determinar caminhos infinitos
- Variações resolvem o problema do loop colocando apenas duas condições:
entrou no loop 0 vezes (ou 1 vez no caso do “do … while”) ou entrou mais de 0
vezes (ou mais de 1 vez no caso do “do … while”).
28. Cobertura de Código
Cobertura de Código
7. Cobertura por Função ou Método
(Function or Method Coverage)
- Métrica que representa a porcentagem de métodos que são executados
- Muito pouco efetivo
- Muito simples de implementar
8. Cobertura por Operador Relacional
(Relational Operator Coverage)
- Métrica que representa a porcentagem de operações relacionais testadas com
valores superiores, inferiores e de fronteira (boundaries)
- Pode ser efetiva
- Pode necessitar de muitos testes
29. Cobertura de Código
Cobertura de Código
9. MC/DC
(Modified Condition/Decision Coverage)
- Utilizada para software Level A (catastróficos)
- Extremamente efetivo.
- Muito simples de implementar.
- Para uma adequação MC/DC (Cobertura 100% MC/DC), pelo menos um teste
deve satisfazer cada uma das condições abaixo:
- Todas as decisões (condicionais) devem ser executadas com todos os
seus possíveis valores
- Todas as expressões de todas as decisões devem ser executadas com
todos os seus possíveis valores
- Todos os pontos de entrada e de saída da aplicação são exercitados
- Cada condição é comprovadamente testada de forma que só ela modifique
a aplicação.
31. Ant
Ant
Propriedades
<property name="src.dir" value="src"/>
<property name="lib.dir" value="lib"/>
…
<property name="lib.common" value="${lib.dir}/common"/>
Propriedades são semelhantes a variáveis. É comum utilizar variáveis com
valores de caminhos, uma vez que esse valores são bem passíveis de mudança
32. Ant
Ant
Criação de Paths
<path id="compile.classpath">
<fileset dir="${lib.dir}/common">
<include name="*.jar"/>
</fileset>
</path>
<path id="test.classpath">
<pathelement location="${build.classes.dir}"/>
<path refid="compile.classpath"/>
</path>
Paths indicam caminhos que deverão representar em algum momento o
classpath de uma compilação java (representado pela diretiva –cp
nos comandos de compilação e execução de uma aplicação JAVA
33. Ant
Ant
Criação de Targets
<target name="init">
<mkdir dir="${build.classes.dir}"/>
</target>
<target name="clean">
<delete dir="${build.classes.dir}"/>
</target>
<target name="compile" depends="init">
<javac srcdir="${src.dir}" destdir="${build.classes.dir}" debug="true">
<classpath refid="compile.classpath"/>
</javac>
</target>
Targets são os principais elementos de um build.xml. Um target representa uma
atividade Ant. Vários comandos podem existir dentro de um target. O código
acima representa apenas uma pequena parte.
34. Ant
Ant
Ant + JUnit
<target name="test" depends="compile.tests">
<junit printsummary="true">
<classpath location="${build.classes.dir}"/>
<classpath refid="test.classpath"/>
<batchtest fork="yes" todir="${reports.tests}”>
<fileset dir="${src.dir}”>
<include name="**/*Test*.java"/>
<exclude name="**/AllTests.java"/>
</fileset>
</batchtest>
</junit>
</target>
Comandos Junit são embutidos nas versões mais novas do Ant, apesar de que,
qualquer aplicação pode incluir seus próprios comandos Ant
35. Ant
Ant
Tarefas Customizadas
(Ex.: Emma)
<!-- directory that contains emma.jar and emma_ant.jar: -->
<property name="emma.dir" value="${basedir}/../lib" />
<path id="emma.lib" >
<pathelement location="${emma.dir}/emma.jar" />
<pathelement location="${emma.dir}/emma_ant.jar" />
</path>
<taskdef resource="emma_ant.properties" classpathref="emma.lib" />
Comandos Taskdef servem para incluir novos comandos ao ANT.
O exemplo acima representa a inclusão de comandos para execução do ANT
utilizando o EMMA.
36. Ant
Ant
Tarefas Customizadas (Cont.)
(Ex.: Emma)
<!-- output directory used for EMMA coverage reports: -->
<property name="coverage.dir" value="${basedir}/coverage" />
<target name="run" depends="init, compile" description="runs the examples" >
<emmajava enabled="${emma.enabled}" libclasspathref="emma.lib”
fullmetadata="yes" sourcepath="${src.dir}”
classname="Main”
classpathref="run.classpath”
>
<filter includes="Main, search.*" />
<txt outfile="${coverage.dir}/coverage.txt" />
<xml outfile="${coverage.dir}/coverage.xml" />
<html outfile="${coverage.dir}/coverage.html" />
</emmajava>
</target>
Apos incusão via taskdef, os comandos (nesse caso “emmajava”) estão
disponíveis para ser utilizado em seu build.xml
40. Test-Driven Development (TDD)
Test-Driven Development (TDD)
• Programadores que escrevem testes são mais produtivos (estudo de
2005)
• Uma maneira de construir software mais rápido
• Habilidade de andar com pequenos passos, certificando-se que esses pão
estão coerentes e corretos
• Cobertura de caminho e de expressão é automaticamente utilizada, sem
nenhum esforço adicional
Vantagens