Prévia do material em texto

1
Técnicas de teste
DE CAIXA BRANCA
conteúdo
1. Teste de Comandos
2. Teste de Desvios
3. Teste de Comandos X Teste de Desvios
4. Outras Técnicas de Teste de Caixa Branca
2
TESTE
De Comandos
TÉNICAS DE TESTE
Particionamento de 
Equivalência (PE)
Análise de Valores Limite 
(AVL)
Teste de Tabela de 
Decisão
Teste de Transição de 
Estado
CAIXA PRETA
Teste de Comandos 
e Cobertura de 
Comandos
Testes de Desvios e 
Cobertura de Desvios
CAIXA BRANCA
Adivinhação de Erros
Teste Exploratório
BASEADO NA 
EXPERIÊNCIA
Teste Baseado em 
Checklist
TÉCNICAS DE TESTE
3
TESTE DE CAIXA BRANCA
• O teste de caixa branca é baseado na 
estrutura interna do objeto de teste.
• É frequentemente associado ao teste de 
componentes.
• No teste de caixa branca, o modelo do objeto 
de teste é a estrutura interna do código.
• A representação pode incluir um grafo de 
fluxo de controle (CFG).
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
TESTE DE CAIXA BRANCA
• O testador possui conhecimento da estrutura 
interna do sistema a ser testado;
• Este conhecimento se torna disponível ao 
testador nas fases finais do desenvolvimento;
• Útil para testar componentes pequenos, pois, 
o nível de detalhe é grande.
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
4
TESTE DE CAIXA BRANCA
As técnicas de teste de caixa 
branca podem ser aplicadas em 
todos os níveis de teste
TESTE DE CAIXA BRANCA
• Teste de Componentes: grafo de fluxo 
de controle;
• Teste de Integração: grafo de 
chamadas, API;
• Teste de Sistema: processos de 
negócios modelado na linguagem 
BPMN, menu do programa;
• Teste de Aceitação: estrutura das 
páginas do site.
5
GRAFO DE FLUXO DE CONTROLE
• Em ciência da computação, um grafo de 
fluxo de controle (control-flow graph - 
CFG) é utilizado;
• Ele representa todos os caminhos que 
podem ser percorridos em um programa 
durante sua execução;
• É representado usando notação de grafo.
1
3
5
7
8
11
GRAFO DE FLUXO DE CONTROLE
Auxilia na criação de casos de testes caixa 
branca
• Vértices: Representam os comandos
• Arestas: Representam o fluxo de controle
Vértice
Aresta
6
GRAFO DE FLUXO DE CONTROLE
Sequência Decisão Repetição
EXEMPLO - GRAFO DE FLUXO DE CONTROLE
1 int buscar(int[] vetor, int chave) {
2
3 int indice = -1;
4
5 for (int i = 0; i y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V F
V
F
EXEMPLO - TESTE DE COMANDOS 1
3
5
6 8
9
11
12
14
V F
V
F
calcularValorZ(2, 11);
12
EXEMPLO - TESTE DE COMANDOS
1 int calcularValorZ(int x, int y) {
2
3 int z = 0;
4
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V F
V
F
calcularValorZ(2, 11);
EXEMPLO - TESTE DE COMANDOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V F
V
F
calcularValorZ(2, 11);
int z = 0;
13
EXEMPLO - TESTE DE COMANDOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V
F
calcularValorZ(2, 11);
if (2 > 11) 
EXEMPLO - TESTE DE COMANDOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
F
V
F
calcularValorZ(2, 11);
z = 2 - 11;
if (2 > 11) 
14
EXEMPLO - TESTE DE COMANDOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
F
V
F
calcularValorZ(2, 11);
z = 2 - 11;
if (2 > 11) 
if (2 > 1) 
EXEMPLO - TESTE DE COMANDOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
F
V
calcularValorZ(2, 11);
z = 2 - 11;
if (2 > 11) 
if (2 > 1) 
z = 9 * 2;
15
EXEMPLO - TESTE DE COMANDOS
calcularValorZ(2, 11);
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13 
14 return z;
15 }
1
3
5
6 8
9
11
12
14
F
V
z = 2 - 11;
if (2 > 11) 
if (2 > 1) 
z = 9 * 2;
return 18;
EXEMPLO - TESTE DE COMANDOS 1
3
5
6 8
9
11
12
14
V F
V
F
calcularValorZ(8, 1);
16
EXEMPLO - TESTE DE COMANDOS
1 int calcularValorZ(int x, int y) {
2
3 int z = 0;
4
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V F
V
F
calcularValorZ(8, 1);
EXEMPLO - TESTE DE COMANDOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V F
V
F
int z = 0;
calcularValorZ(8, 1);
17
EXEMPLO - TESTE DE COMANDOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V
F
if (8 > 1) 
calcularValorZ(8,1);
EXEMPLO - TESTE DE COMANDOS 1
3
5
6 8
9
11
12
14
V
F
if (8 > 1) 
calcularValorZ(8, 1);
V
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13 
14 return z;
15 }
z = 8 - 1;
18
EXEMPLO - TESTE DE COMANDOS 1
3
5
6 8
9
11
12
14
V
F
if (8 > 1) 
calcularValorZ(8, 1);
V
z = 8 - 1;
1 int calcularValorZ(int x, int y) {
2
3 int z = 0;
4
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13 
14 return z;
15 } if (8 > 1) 
EXEMPLO - TESTE DE COMANDOS 1
3
5
6 8
9
11
12
14
V
if (8 > 1) 
calcularValorZ(8, 1);
V
z = 8 - 1;
if (8 > 1) 
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
z = 7 * 2;
19
EXEMPLO - TESTE DE COMANDOS
calcularValorZ(8, 1);
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V
if (8 > 1) 
V
z = 8 - 1;
if (8 > 1) 
z = 7 * 2;
return 14;
calcularValorZ(8, 1);
1
3
5
6 8
9
11
12
14
V
if (8 > 1) 
V
z = 8 - 1;
if (8 > 1) 
z = 7 * 2;
return 14;
1
3
5
6 8
9
11
12
14
F
V
z = 2 - 11;
if (2 > 11) 
if (2 > 1) 
z = 9 * 2;
return 18;
calcularValorZ(2, 11);
20
CASOS DE TESTE - TESTE DE COMANDOS
• TC1:〈(2, 11), 18 〉
• TC2:〈(8, 1), 14 〉
1
3
5
6 8
9
11
12
14
F
V
return 18;
1
3
5
6 8
9
11
12
14
V
V
return 14;
TC1 TC2
CASOS DE TESTE - TESTE DE COMANDOS
• Os resultados esperados nos casos 
de teste não são baseados no código;
• O código é o que está sendo testado 
e não pode ser seu próprio oráculo;
• Os resultados esperados são 
derivados de uma especificação 
externa ao código.
TC1:〈(2, 11), 18 〉
TC2: 〈(8, 1), 14 〉
21
CASOS DE TESTE - TESTE DE COMANDOS
Exemplo Especificação
• O programa recebe dois números 
naturais e então subtrai o menor do 
maior;
• Se o primeiro número for maior que 1, o 
valor é dobrado novamente;
• O programa retorna o valor calculado 
desta forma.
TC1:〈(2, 11), 18 〉
TC2: 〈(8, 1), 14 〉
COBERTURA DE COMANDOS
• Os itens de cobertura são as declarações 
executáveis.
• A cobertura de declarações é calculada 
como a porcentagem de instruções 
executáveis cobertas pelos casos de 
teste.
• Não considera declarações que não são 
executáveis, como comentários ou 
cabeçalhos de funções.
TC1:〈(2, 11), 18 〉
TC2: 〈(8, 1), 14 〉
22
COBERTURA DE COMANDOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
• Número total de instruções executáveis: 8
• Linhas 7 e 9 é não são comandos 
executáveis
COBERTURA DE COMANDOS
A. Instruções executáveis cobertas pelos 
casos de teste 
B. Número total de instruções executáveis
23
COBERTURA DE COMANDOS
• TC1:〈(2, 11), 18 〉
• Instruções Testadas: 7
• Número total de Instruções: 8
• Alcançamos uma cobertura de 87,5%.
1
3
5
6 8
9
11
12
14
F
V
return 18;
1
3
5
6 8
9
11
12
14
V
V
return 14;
COBERTURA DE COMANDOS
• TC2:〈(8, 1), 14 〉
• Instruções Testadas: 7
• Número total de Instruções: 8
• Alcançamos uma cobertura de 87,5%.
24
1
3
5
6 8
9
11
12
14
V
V
return 14;
COBERTURA DE COMANDOS
• Se nosso conjunto de testes contiver tanto TC1 
quanto TC2
• A cobertura será de 100%.
• Isso ocorre porque juntos, esses 2 casos de 
teste exercitam todas as 8 instruções 
executáveis.
1
3
5
6 8
9
11
12
14
F
V
return 18;
TESTE
De Desvios
25
TÉNICAS DE TESTE
Particionamento de 
Equivalência (PE)
Análise de Valores Limite 
(AVL)
Teste de Tabela de 
Decisão
Teste de Transição de 
Estado
CAIXA PRETA
Teste de Comandos 
e Cobertura de 
Comandos
Testes de Desvios e 
Cobertura de Desvios
CAIXA BRANCA
Adivinhação de Erros
Teste Exploratório
BASEADO NA 
EXPERIÊNCIA
Teste Baseado em 
Checklist
TÉCNICAS DE TESTE
TESTE DE DESVIOS
• Um desvio é um fluxo de controle entre 
2 vértices de um grafo de fluxo de 
controle;
• Um desvio pode ser condicional ou 
incondicional.
1
3
5
7
8
11
26
DESVIO INCONDICIONAL
• Significa que após a execução da 
declaração A ser concluída;
• O controle deve mover-se para a 
declaração B.
A
B
DESVIO CONDICIONAL
• Significa que após a execução da 
declaração A ser concluída;
• O controle pode ou não avançar 
para a declaração B;
A
D
CB
FV
27
DESVIO CONDICIONAL
• Desvios condicionais saem de vértices 
de decisão;
• Lugares no código onde uma decisão 
é tomada na qual o curso adicional do 
controle depende.
• Decisão: if, if/else, switch
• Repetição: while, for, do/while
A
D
CB
A
B
C
Decisão Repetição
FV
F
V
TESTE DE DESVIOS
• Cada desvio ou decisão consiste em uma 
condição simples ou composta 
• Deve ser avaliada, pelo menos uma vez como 
verdadeira e uma como falsa
• Para n condições, exige no máximo n + 1 
casos de teste;
A
D
CB
Decisão
FV
28
TESTE DE DESVIOS
• Em termos de grafo de fluxo de controle;
• Consiste em garantir que todas as arestas 
sejam exercitadas pelo menos uma vez pelo 
conjunto de testes;
1
3
5
7
8
11
EXEMPLO - TESTE DE DESVIOS
1 int calcularValorZ(int x, int y) {
2
3 int z = 0;
4
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V F
V
F
29
EXEMPLO - TESTE DE DESVIOS 1
3
5
6 8
9
11
12
14
V F
V
F
calcularValorZ(2, 11);
EXEMPLO - TESTE DE DESVIOS
1 int calcularValorZ(int x, int y) {
2
3 int z = 0;
4
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V F
V
F
calcularValorZ(2, 11);
int z = 0;
30
EXEMPLO - TESTE DE DESVIOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V
F
calcularValorZ(2, 11);
if (2 > 11) 
EXEMPLO - TESTE DE DESVIOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
F
V
F
calcularValorZ(2, 11);
z = 2 - 11;
if (2 > 11) 
31
EXEMPLO - TESTE DE DESVIOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
F
V
F
calcularValorZ(2, 11);
z = 2 - 11;
if (2 > 11) 
if (2 > 1) 
EXEMPLO - TESTE DE DESVIOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
F
V
calcularValorZ(2, 11);
z = 2 - 11;
if (2 > 11) 
if (2 > 1) 
z = 9 * 2;
32
EXEMPLO - TESTE DE COMANDOS
calcularValorZ(2, 11);
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13 
14 return z;
15 }
1
3
5
6 8
9
11
12
14
F
V
z = 2 - 11;
if (2 > 11) 
if (2 > 1) 
z = 9 * 2;
return 18;
EXEMPLO - TESTE DE DESVIOS 1
3
5
6 8
9
11
12
14
V F
V
F
calcularValorZ(8, 1);
33
1 int calcularValorZ(int x, int y) {
2
3 int z = 0;
45 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
EXEMPLO - TESTE DE DESVIOS 1
3
5
6 8
9
11
12
14
V F
V
F
calcularValorZ(8, 1);
int z = 0;
EXEMPLO - TESTE DE DESVIOS
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V
F
if (8 > 1) 
calcularValorZ(8, 1);
34
EXEMPLO - TESTE DE DESVIOS 1
3
5
6 8
9
11
12
14
V
F
if (8 > 1) 
calcularValorZ(8, 1);
V
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13 
14 return z;
15 }
z = 8 - 1;
EXEMPLO - TESTE DE DESVIOS 1
3
5
6 8
9
11
12
14
V
F
if (8 > 1) 
calcularValorZ(8, 1);
V
z = 8 - 1;
1 int calcularValorZ(int x, int y) {
2
3 int z = 0;
4
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13 
14 return z;
15 } if (8 > 1) 
35
EXEMPLO - TESTE DE COMANDOS 1
3
5
6 8
9
11
12
14
V
if (8 > 1) 
calcularValorZ(8, 1);
V
z = 8 - 1;
if (8 > 1) 
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
z = 7 * 2;
EXEMPLO - TESTE DE DESVIOS
calcularValorZ(8, 1);
1 int calcularValorZ(int x, int y) {
2 
3 int z = 0;
4 
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10 
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
1
3
5
6 8
9
11
12
14
V
if (8 > 1) 
V
z = 8 - 1;
if (8 > 1) 
z = 7 * 2;
return 14;
36
calcularValorZ(8, 1);
1
3
5
6 8
9
11
12
14
V
if (8 > 1) 
V
z = 8 - 1;
if (8 > 1) 
z = 7 * 2;
return 14;
1
3
5
6 8
9
11
12
14
F
V
z = 2 - 11;
if (2 > 11) 
if (2 > 1) 
z = 9 * 2;
return 18;
calcularValorZ(2, 11);
calcularValorZ(8, 1);
1
3
5
6 8
9
11
12
14
V
if (8 > 1) 
V
z = 8 - 1;
if (8 > 1) 
z = 7 * 2;
return 14;
1
3
5
6 8
9
11
12
14
F
V
z = 2 - 11;
if (2 > 11) 
if (2 > 1) 
z = 9 * 2;
return 18;
calcularValorZ(2, 11);
37
EXEMPLO - TESTE DE DESVIOS 1
3
5
6 8
9
11
12
14
V F
V
F
Total de Desvios: 9
• 1 → 3
• 3 → 5
• 5 → 6
• 5 → 8
• 6 → 11
• 8 → 11
• 11 →12
• 11 → 14
• 12 → 14
EXEMPLO - TESTE DE DESVIOS 1
3
5
6 8
11
12
14
V F
V
F
• Total de Desvios: 9
• Iremos ignorar os seguintes desvios:
• 6 → 9
• 8 → 9
• Linhas 9 não é um comando executável
1 int calcularValorZ(int x, int y) {
2
3 int z = 0;
4
5 if (x > y) {
6 z = x - y;
7 } else {
8 z = y - x;
9 }
10
11 if (x > 1)
12 z = z * 2;
13
14 return z;
15 }
38
COBERTURA DE DESVIOS
A. Desvios para instruções executáveis 
cobertas pelos casos de teste 
B. Número total de desvios para instruções 
executáveis
COBERTURA DE DESVIOS
TC1:〈(2, 11), 18 〉
Desvios Cobertos: 6
1. Incondicional: 1 → 3
2. Incondicional: 3 → 5
3. Condicional: 5 → 8
4. Incondicional: 8 → 11
5. Condicional: 11 →12
6. Incondicional: 12 → 14
1
3
5
6 8
11
12
14
F
V
return 18;
39
COBERTURA DE DESVIOS
TC1:〈(2, 11), 18 〉
• Desvios Cobertos: 6
• Total de Desvios: 9
• Cobertura: 6 / 9 = 66,66%
1
3
5
6 8
11
12
14
F
V
return 18;
COBERTURA DE DESVIOS
TC2:〈(8, 1), 14 〉
Desvios Cobertos: 6
1. Incondicional: 1 → 3
2. Incondicional: 3 → 5
3. Condicional: 5 → 6
4. Incondicional: 6 → 11
5. Condicional: 11 →12
6. Incondicional: 12 → 14
1
3
5
6 8
11
12
14
V
V
return 14;
40
COBERTURA DE DESVIOS
TC2:〈(8, 1), 14 〉
• Desvios Cobertos: 6
• Total de Desvios: 9
• Cobertura: 6 / 9 = 66,66%
1
3
5
6 8
11
12
14
V
V
return 14;
COBERTURA DE DESVIOS
Desvios Cobertos TC1 e TC2: 8
1. Incondicional: 1 → 3
2. Incondicional: 3 → 5
3. Condicional: 5 → 8
4. Condicional: 5 → 6
5. Incondicional: 8 → 11
6. Incondicional: 6 → 11
7. Condicional: 11 →12
8. Incondicional: 12 → 14
1
3
5
6 8
11
12
14
V
V
return 14;
1
3
5
6 8
11
12
14
F
V
return 18;
TC2:〈(8, 1), 14〉TC1:〈(2, 11), 18〉
41
COBERTURA DE DESVIOS
• Desvio não coberto pelos casos de testes
• Condicional: 11 →12
• Para alcançarmos 100% de cobertura, 
deveríamos propor um caso de teste que 
passe pelo desvio 11 →12
1
3
5
6 8
11
12
14
V
V
return 14;
1
3
5
6 8
11
12
14
F
V
return 18;
TC2:〈(8, 1), 14〉TC1:〈(2, 11), 18〉
EXEMPLO 2 – 100% DE COBERTURA DE DESVIOS
1 void repetir(int n) {
2
3 int contador = 1;
4 
5 while (contador 0)
4 x = x * y;
5
6 return x;
7 }
46
EXEMPLO
• O programador errou e implementou 
o código com um defeito;
• Acidentalmente ele trocou o sinal da 
multiplicação pela soma;
1 int multiplicarValores(int x, int y) { 
2
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
47
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2 
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2 
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
if (2 > 0)
48
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2 
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
x = 2 + 2
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2 
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
return 4;
x = 2 + 2
49
EXEMPLO
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
return 4;
x = 2 + 2
• TC:〈(2, 2), 4 〉
• Instruções Testadas: 4
• Número total de Instruções: 4
• Alcançamos uma cobertura de 100%.
EXEMPLO
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
return 4;
x = 2 + 2
• O Comando 4 será executado 
incorretamente devido o defeitono código
• Coincidentemente 2 * 2 é igual a 2 + 2
• Apesar do defeito, o resultado retornado 
será correto
• Este exemplo demonstra porque cobertura 
de comando é uma técnica fraca 
50
HIPÓTESE – TESTE DE DESVIOS
O teste de desvios é baseado na seguinte 
hipótese de erro: 
• Se há um defeito no programa;
• Ele causa um fluxo de controle errôneo.
1
3
5
6
8
HIPÓTESE – TESTE DE DESVIOS
• Em uma situação onde alcançamos 100% de 
cobertura de desvios
• Devemos ter exercido pelo menos uma 
transição errada 
• Exemplo: o valor da decisão deveria ser 
verdadeiro, mas foi falso.
• Isso faz com que o programa execute as 
declarações erradas.
• E, possivelmente resultará em uma falha.
1
3
5
6
8
51
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2 
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
52
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2 
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
if (2 > 0)
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2 
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
x = 2 + 2
53
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2 
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(2, 2);
1
3
4
6
TC:〈(2, 2), 4〉
return 4;
x = 2 + 2
EXEMPLO
multiplicarValores(2, 2);
1
3
4
6
TC1:〈(2, 2), 4〉
return 4;
x = 2 + 2
• TC1:〈(2, 2), 4 〉
• Desvios Testados: 3
• Número total de Desvios: 4
• Alcançamos uma cobertura de 75%.
54
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(0, 5);
1
3
4
6
TC2:〈(0, 5), 0〉
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2 
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
multiplicarValores(0, 5);
1
3
4
6
TC2:〈(0, 5), 0〉
if (0 > 0)
55
EXEMPLO
1 int multiplicarValores(int x, int y) { 
2 
3 if (x > 0)
4 x = x + y;
5
6 return x;
7 }
1
3
4
6
TC2:〈(0, 5), 0〉
return 0;
multiplicarValores(0, 5);
EXEMPLO
multiplicarValores(0, 5);
• TC2:〈(0, 5), 0 〉
• Desvios Testados: 2
• Número total de Desvios: 4
• Alcançamos uma cobertura de 50%.
1
3
4
6
TC2:〈(0, 5), 0〉
56
EXEMPLO
1
3
4
6
TC2:〈(0, 5), 0〉
• Se nosso conjunto de testes contiver tanto TC1 
quanto TC2
• A cobertura será de 100%.
• Isso ocorre porque juntos, esses 2 casos de 
teste exercitam todos os 4 desvios
1
3
4
6
TC1:〈(2, 2), 4〉
EXEMPLO
1
3
4
6
TC2:〈(0, 5), 0〉
• Apesar de 100% de cobertura;
• Os 2 casos de testes não 
identificaram o defeito;
1
3
4
6
TC1:〈(2, 2), 4〉
57
COMANDOS X DESVIOS
1
3
4
6
TC2:〈(0, 5), 0〉
• Alcançar 100% de cobertura de 
desvios 
• Garante a obtenção de 100% de 
cobertura de comandos.
• Logo, não precisamos verificar a 
cobertura de comandos 
separadamente nesse caso.
1
3
4
6
TC1:〈(2, 2), 4〉
1
3
4
6
TC:〈(2, 2), 4〉
VANTAGENS DAS TÉCNICAS DE TESTES DE CAIXA BRANCA
• Toda a implementação do software é 
considerada durante o teste.
• Facilita a detecção de defeitos, mesmo 
quando a especificação do software é 
pouco clara ou incompleta.
• O design do teste é independente da 
especificação.
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
58
FRAQUEZAS DAS TÉCNICAS DE TESTES DE CAIXA BRANCA
• Pode falhar em detectar defeitos 
resultantes da falta de funcionalidade
• Se o software não implementar um 
ou mais requisitos.
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
TESTES DE CAIXA BRANCA X TESTE DE CAIXA PRETA
O teste de caixa preta não mede a 
cobertura real do código.
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
59
TESTES DE CAIXA BRANCA X TESTE DE CAIXA PRETA
• O teste de caixa branca fornece uma 
medida objetiva de cobertura.
• Ele oferece informações necessárias 
para gerar testes adicionais que 
aumentem a cobertura 
• E, consequentemente, a confiança no 
código.
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
Outras técnicas
De Teste de Caixa Branca
60
TESTES DE CAIXA BRANCA X TESTE DE CAIXA PRETA
Teste de Comandos e Teste de Desvios
• Ambas as técnicas estão associadas ao 
código
• São aplicadas principalmente no teste de 
componentes.
• Além dessas, existem muitas outras 
técnicas de caixa branca
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
TESTES DE CAIXA BRANCA X TESTE DE CAIXA PRETA
• Teste de fluxo de dados
• Teste de fluxo de controle
• Cobertura de condição/decisão 
modificada
• Teste de caminho primário
• Teste de caminho
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
61
TESTE DE FLUXO DE DADOS
• Todas as definições de variáveis devem 
ser exercitadas pelo menos uma vez;
• Uma variável é definida em um comando 
quando seu valor é atribuído ou alterado;
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
TESTE DE FLUXO DE DADOS
• Todos os usos de variáveis devem ser 
exercitadas pelo menos uma vez
• Uma variável é usada em um comando 
quando o seu valor é utilizado e não é 
alterado.
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
62
TESTES DE CAIXA BRANCA X TESTE DE CAIXA PRETA
• Técnicas de teste de caixa branca mais 
avançadas 
• São frequentemente usadas para testar 
sistemas críticos para a segurança, como:
• Software de instrumentos médicos.
• Software aeroespacial.
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
TESTES DE CAIXA BRANCA X TESTE DE CAIXA PRETA
• Teste MC/DC (Teste de decisão de 
condições múltiplas)
• Teste de múltiplas condições
• Teste de laço
• Teste de caminho base
CAIXA PRETA
CAIXA BRANCA
BASEADO NA 
EXPERIÊNCIA
TÉCNICAS DE TESTE
63
TESTE DE MUTAÇÃO
O Teste de Mutação, ou Análise de 
Mutantes, é um critério de teste 
baseado em defeitos.
TESTES DE MUTAÇÃO
• Utiliza defeitos típicos do processo de 
implementação de software para derivar os 
requisitos de teste;
• O programa em teste é alterado diversas vezes;
• Criando um conjunto de programas alternativos 
(mutantes).
64
OBJETIVOS DOS TESTE DE MUTAÇÃO
Verificar se os casos de teste existentes 
• São capazes de detectar as pequenas 
alterações (mutações) no código do 
programa;
• Ou seja, se são sensíveis a falhas 
introduzidas intencionalmente.
OBJETIVOS DOS TESTE DE MUTAÇÃO
• Avaliar a Qualidade dos Testes: Verificar se 
os casos de teste são robustos e eficazes;
• Identificar Pontos Fracos nos Testes: 
Revelar partes do código que não estão 
sendo adequadamente testadas;
• Melhorar a Cobertura de Testes: Incentivar 
a criação de testes adicionais para cobrir 
cenários não detectados inicialmente.
65
COMO FUNCIONA O TESTE DE MUTAÇÃO?
1. Gerar Mutantes
2. Executar Testes
3. Analisar Resultados
1. GERAR MUTANTES
• São criadas versões modificadas do código 
original, chamadas de mutantes;
• Cada mutante contém uma pequena 
alteração como:
• Mudar um operador aritmético ou lógico
• Alterar um valor constante, etc.
66
MUTAÇÕES
TraduçãoNomeSigla
Eliminação de ComandoStatement DeletionSSDL
Troca de Operador RelacionalRelational Operator ReplacementORRN
Armadilha em Condição IFTrap On IF ConditionSTRI
Troca de Referência a Variável EscalarScalar Variable Reference ReplacementVSRR
SSDL - ELIMINAÇÃO DE COMANDO
• Retirar um comando ou linha de 
código do programa;
• Verificar se os casos de teste 
conseguem detectar a ausência 
dessa linha de código;
• Exemplo: Linha 7 foi removida
1 int buscar(int[] vetor, int chave) {
2
3 int indice = -1;
4
5 for (int i = 0; i• Substitui operadores relacionais por outros 
operadores relacionais. 
• O objetivo é verificar se os casos de teste 
conseguem detectar a alteração no 
comportamento das comparações.
public boolean ePar(int numero) {
int restoDivisao = numero % 2;
if (restoDivisao == 0) {
return true;
} else {
return false;
}
}
if (restoDivisao != 0) 
if (restoDivisao >= 0) 
if (restoDivisao 0) 
if (restoDivisao > Line Coverage (for mutated classes only): 5/8 (63%)
>> Generated 5 mutations Killed 4 (80%)
>> Mutations with no coverage 1. Test strength 100%
>> Ran 4 tests (0.8 tests per mutation)
-------------------------------------------------------
3. ANALISAR RESULTADOS
• Foram geradas 5 mutações no total;
• Cada mutação representa uma pequena 
alteração no código;
• Dessas mutações 4 foram "mortas“;
• Isso significa que os casos de teste existentes 
detectaram a alteração e falharam como 
esperado.
======================================================
- Statistics
======================================================
>> Line Coverage (for mutated classes only): 5/8 (63%)
>> Generated 5 mutations Killed 4 (80%)
>> Mutations with no coverage 1. Test strength 100%
>> Ran 4 tests (0.8 tests per mutation)
-------------------------------------------------------
76
3. ANALISAR RESULTADOS
• A taxa de mutações mortas é de 80%;
• 4 mutações mortas de 5 mutações geradas;
• Este é um bom indicador da eficácia dos seus 
testes;
• Se a maioria das mutações são detectadas e 
causam falhas nos testes, isso sugere que os 
testes são robustos.
======================================================
- Statistics
======================================================
>> Line Coverage (for mutated classes only): 5/8 (63%)
>> Generated 5 mutations Killed 4 (80%)
>> Mutations with no coverage 1. Test strength 100%
>> Ran 4 tests (0.8 tests per mutation)
-------------------------------------------------------
3. ANALISAR RESULTADOS
• Houve 1 mutação que não foi coberta por 
nenhum teste. 
• Isso significa que a linha de código onde essa 
mutação foi inserida não foi executada por 
nenhum dos casos de teste. 
• É uma indicação de que há partes do código 
que não estão sendo testadas.
======================================================
- Statistics
======================================================
>> Line Coverage (for mutated classes only): 5/8 (63%)
>> Generated 5 mutations Killed 4 (80%)
>> Mutations with no coverage 1. Test strength 100%
>> Ran 4 tests (0.8 tests per mutation)
-------------------------------------------------------
77
3. ANALISAR RESULTADOS
• Houve 1 mutação que não foi coberta por 
nenhum teste. 
• Isso significa que a linha de código onde essa 
mutação foi inserida não foi executada por 
nenhum dos casos de teste. 
• É uma indicação de que há partes do código 
que não estão sendo testadas.
======================================================
- Statistics
======================================================
>> Line Coverage (for mutated classes only): 5/8 (63%)
>> Generated 5 mutations Killed 4 (80%)
>> Mutations with no coverage 1. Test strength 100%
>> Ran 4 tests (0.8 tests per mutation)
-------------------------------------------------------
3. ANALISAR RESULTADOS
• A força dos testes é 100%. 
• Todas as mutações que foram cobertas pelos 
testes foram detectadas. 
• Em outras palavras, todas as mutações 
cobertas foram mortas.
======================================================
- Statistics
======================================================
>> Line Coverage (for mutated classes only): 5/8 (63%)>> Generated 5 mutations Killed 4 (80%)
>> Mutations with no coverage 1. Test strength 100%
>> Ran 4 tests (0.8 tests per mutation)
-------------------------------------------------------
78
3. ANALISAR RESULTADOS
• Em média, 0.8 testes foram executados por 
mutação. 
• Isso é calculado dividindo o número total de 
testes pelo número de mutações 
• 4 testes / 5 mutações = 0.8
======================================================
- Statistics
======================================================
>> Line Coverage (for mutated classes only): 5/8 (63%)
>> Generated 5 mutations Killed 4 (80%)
>> Mutations with no coverage 1. Test strength 100%
>> Ran 4 tests (0.8 tests per mutation)
-------------------------------------------------------
FERRAMENTAS
• PIT (Java): https://pitest.org/
• Stryker (JavaScript / TypeScript, C#, Scala): 
https://stryker-mutator.io/
• MutPy (Python): 
https://github.com/mutpy/mutpy
79
EXEMPLO PRÁTICO – TESTE DE MUTAÇÃO
INSTALAÇÃO PITEST - MAVEN | POM.XML
org.pitest
pitest-maven
1.16.1
org.pitest
pitest-junit5-plugin
1.2.1
80
CLASSE
public class Calculadora {
public boolean ePositivo(int numero) {
boolean resultado = false;
if (numero >= 0)
resultado = true;
return resultado;
}
}
CLASSE DE TESTE
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class CalculadoraTest {
private final Calculadora calculadoraSobTeste = new Calculadora();
@Test
void deveSerPositivo() {
int numero = 1;
boolean saidaEsperada = true;
boolean resultado = calculadoraSobTeste.ePositivo(numero);
assertEquals(saidaEsperada, resultado);
}
@Test
void deveSerNegativo() {
int numero = -1;
boolean saidaEsperada = false;
boolean resultado = calculadoraSobTeste.ePositivo(numero);
assertEquals(saidaEsperada, resultado);
}
}
81
EXECUTE O PITEST
mvn test-compile org.pitest:pitest-maven:mutationCoverage
ANALISE OS RESULTADOS
========================================================
- Statistics
========================================================
>> Line Coverage (for mutated classes only): 5/5 (100%)
>> Generated 4 mutations Killed 3 (75%)
>> Mutations with no coverage 0. Test strength 75%
>> Ran 6 tests (1.5 tests per mutation)
82
ANALISE OS RESULTADOS
========================================================
- Statistics
========================================================
>> Line Coverage (for mutated classes only): 5/5 (100%)
>> Generated 4 mutations Killed 3 (75%)
>> Mutations with no coverage 0. Test strength 75%
>> Ran 6 tests (1.5 tests per mutation)
• Foram geradas 4 mutações no total;
• Cada mutação representa uma pequena 
alteração no código;
• Dessas mutações 3 foram "mortas“;
• Isso significa que temos 1 mutante vivo
• Indicando que o conjunto de testes não 
conseguiu detectar a alteração.
ANALISE OS RESULTADOS
O mutante vivo é uma 
CONDITIONALS_BOUNDARY
83
CONDITIONALS_BOUNDARY
MutaçãoOperador
=>
>>=
if (numero >= 0)
resultado = true;
if (numero > 0)
resultado = true;
Original Mutação
MELHORAR O SCORE DE MUTAÇÃO
• Vamos criar um caso de teste adicional;
• Para cobrir o cenário não detectado 
inicialmente; 
• Melhorar o score de mutação ao matar 
o mutante sobrevivente.
@Test
void deveSerZero() {
int numero = 0;
boolean saidaEsperada = true;
boolean resultado = calculadoraSobTeste.ePositivo(numero);
assertEquals(saidaEsperada, resultado);
}
84
CLASSE DE TESTE class CalculadoraTest {
private final Calculadora calculadoraSobTeste = new Calculadora();
@Test
void deveSerPositivo() {
int numero = 1;
boolean saidaEsperada = true;
boolean resultado = calculadoraSobTeste.ePositivo(numero);
assertEquals(saidaEsperada, resultado);
}
@Test
void deveSerZero() {
int numero = 0;
boolean saidaEsperada = true;
boolean resultado = calculadoraSobTeste.ePositivo(numero);
assertEquals(saidaEsperada, resultado);
}
@Test
void deveSerNegativo() {
int numero = -1;
boolean saidaEsperada = false;
boolean resultado = calculadoraSobTeste.ePositivo(numero);
assertEquals(saidaEsperada, resultado);
}
}
=======================================================
- Statistics
=======================================================
>> Line Coverage (for mutated classes only): 5/5 (100%)
>> Generated 4 mutations Killed 4 (100%)
>> Mutations with no coverage 0. Test strength 100%
>> Ran 7 tests (1.75 tests per mutation)
RESULTADOS
=======================================================
- Statistics
=======================================================
>> Line Coverage (for mutated classes only): 5/5 (100%)
>> Generated 4 mutations Killed 4 (100%)
>> Mutations with no coverage 0. Test strength 100%
>> Ran 7 tests (1.75 tests per mutation)
85
BIBLIOGRAFIA
STAPP, Lucjan; ROMAN, Adam; PILAETEN, Micha
ël. ISTQB – Certified Tester Foundation Level: A 
Self-Study Guide Syllabus v4.0. Chapter 2. Testing 
in the Context of a Software Development Cycle - Test 
Levels. Springer, 2023.
BIBLIOGRAFIA
MYERS, Glenford J.; BADGETT, Tom; SANDLER, 
Corey. The Art of Software Testing. Wiley, 2011.
86
BIBLIOGRAFIA
SOMMERVILLE, Ian. Engenharia de Software. Cap. 2 
– Processo de Software. pág. 18. Cap. 3 –
Desenvolvimento Ágil de Software. pág. 38. Pearson, 
2019.
BIBLIOGRAFIA
PRESSMAN, Roger S.; MAXIM, Bruce R. Engenharia 
de Software: Uma Abordagem Profissional. Cap. 
4.1 Modelos de Processos Prescritivos, pág. 41. 
AMGH, 2021.
87
BIBLIOGRAFIA
BOURQUE, Pierre.; FAIRLEY, Richard E. (Dick). 
SWEBOK V3.0. Chapter 8. Software Engineering 
Process, pág. 81. AMGH, 2021.
Diego Augusto Barros é bacharel em Sistemas de
Informação pela Pontifícia Universidade Católica de Minas
Gerais (2012) e mestre em Ciência da Computação pela
Universidade Federal de Minas Gerais (2015).
Sua pesquisa concentra-se nas áreas de Visualização de
Dados e Interação Humano-computador, e investiga
fatores cognitivos e perceptivos envolvidos na análise de
grandes conjuntos de dados, que resultam em novos
sistemas interativos para comunicação e análise visual.
Seus principais interesses nas áreas são: visualização de
informação, Visual Analytics, métodos de avaliação de
interfaces, interação com sistemas, tecnologias web,
sistemas de informação, engenharia de software e
informática na educação.
diegoaugustobarros.com
@diegoaugustobarros
@profdiegoaugusto
PROF. DIEGO AUGUSTO BARROS