Aula 05 - Testes de Software

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

*
*
*
Unidade 2 – Parte II
Técnicas de 
Teste de Software
Caixa Branca
*
*
*
2.2. Teste de Caminho Básico
 Técnica de teste de caixa branca inicialmente proposta por Tom McCabe.
Permite ao projetista do caso de teste derivar uma medida da complexidade lógica de um projeto procedimental e usá-la para definir um conjunto básico de caminhos de execução;
Os casos de teste derivados para exercitarem o conjunto básico têm garantia de executar cada instrução do programa pelo menos uma vez durante a atividade de teste.
*
*
*
Notação de Grafo de Fluxo
Notação simples para entendimento do fluxo de controle lógico. Construções estruturadas na forma de grafo de fluxo:
Sequência
Se
Enquanto, faça
*
*
*
Notação de Grafo de Fluxo (cont.)
Círculo/nó: uma ou mais instruções procedimentais.
Arcos/ramos: fluxo de controle
Faça até
...
Caso ou Conforme
*
*
*
Notação de Grafo de Fluxo (cont.)
Um ramo deve terminar em um nó, mesmo que o último não represente quaisquer instruções procedimentais.
Regiões: áreas delimitadas pelos ramos e nós. Ao contá-las, devemos incluir a área fora do grafo também.
Qualquer representação de projeto procedimental pode ser traduzida num grafo de fluxo.			 
*
*
*
Notação de Grafo de Fluxo (cont.)
Exemplo: Representação projeto procedimental (fluxograma) e seu correspondente grafo de fluxo.
1
2
3
6
7
8
4
5
9
10
11
1
2,3
6
7
8
9
4,5
10
11
nó
ramo
R1
R2
R3
R4
Região
*
*
*
Exemplo: Segmento de programa fonte e seu correspondente grafo de fluxo.
 procedure:sort
1: do while records remain
 read record;		
2: if record field1 = 0 
3: then process record;					
 store in buffer;
	 increment counter;
4: else if record field2 = 0
5: then reset counter;
6: else process record;
 store in file;
7: endif
 endif
8: enddo
9: end 		 			
Notação de Grafo de Fluxo (cont.)
1
2
4
6
5
7
3
8
9
*
*
*
Notação de Grafo de Fluxo (cont.)
Condições Compostas: um ou mais operadores booleanos (OR, AND, NAND, NOR lógicos) estão presentes numa instrução condicional.
	 
 	.
	.
	.
 IF a OR b 
 then procedure x				
 else procedure y
 ENDIF 		 
 Um nó separado para cada condição a, b da declaração composta
 Nó predicativo: contém uma condição e é caracterizado por 2 ou + ramos saindo dele.
1
2
4
3
 
3
Nó predicativo
1
2
3
4
*
*
*
Complexidade Ciclomática 
 Definição: métrica de software que proporciona uma medida quantitativa da complexidade lógica de um programa.
No contexto do método de teste de caminho básico: valor computado da complexidade ciclomática define o número de caminhos independentes do conjunto básico de um programa e oferece-nos um limite máximo para o número de testes que deve ser realizado para garantir que todas as instruções sejam executadas pelo menos 1 vez.
Caminho independente: qualquer caminho através do programa que introduza pelo menos um novo conjunto de instruções de processamento ou uma nova condição.
*
*
*
Complexidade Ciclomática (cont.)
Em termos do grafo de fluxo: caminho independente deve incluir pelo menos um ramo que não tenha sido atravessado.
 Caminho 1: 1-11
 Caminho 2: 1-2-3-4-5-10-1 ...
 Caminho 3: 1-2-3-6-8-9-10-1 ...
 Caminho 4: 1-2-3-6-7-9-10-1 ... 					 
 
 Cada novo caminho introduz 
 um novo ramo. 
 O caminho:
 1-2-3-4-5-10-1-2-3-6-8-9-10-1-11
Não é independente! É combinação
de caminhos já definidos e não atravessa
nenhum novo ramo. 			 			
1
2,3
6
7
8
9
4,5
10
11
*
*
*
Complexidade Ciclomática (cont.) 
 Caminhos 1, 2, 3 e 4: conjunto básico para o respectivo grafo de fluxo. 
 Se testes puderem ser projetados para forçar a execução desses caminhos, cada instrução do programa terá garantia de ser executada 1 vez pelo menos.
 O conjunto básico não é único  Como saber quantos caminhos devemos procurar? 
 Utiliza-se o cálculo da complexidade ciclomática!!
*
*
*
Complexidade Ciclomática (cont.) 
 A complexidade ciclomática, V(G), pode ser computada através de uma das 3 seguintes formas:
	1. V(G) = Número de regiões do grafo de fluxo 
	2. V(G) = E – N + 2, onde E = qt. Ramos do grafo de fluxo 
				 N = qt. Nós do grafo de fluxo
	3. V(G) = P + 1, onde P = qt. Nós predicativos
 V(G) oferece um limite máximo para o número de caminhos independentes que constitui o conjunto básico e, portanto, um limite máximo de número de testes que deve ser projetado e executado.
*
*
*
Complexidade Ciclomática (cont.)
1
2,3
6
7
8
9
4,5
10
11
nó
ramo
R1
R2
R3
R4
Região
Exemplo: 
V(G) = 4 regiões
V(G) = 11 ramos – 9 nós + 2 = 4
V(G) = 3 nós predicativos + 1 = 4
*
*
*
Derivando Casos de Teste 
PROCEDURE média;
 * Este procedimento calcula a média de 100 números ou menos que se situem entre valores- 	limite; ele também calcula a soma e o total de números válidos.
 INTERFACE RETORNA média, total.entradas, total.validas;
 INTERFACE ACEITA valor, mínimo, máximo;
 TIPO valor[1:100] É VETOR DE ESCALA;
 TIPO média, total.entradas, total.válidas;
 mínimo, máximo, soma é ESCALA;
 TIPO i É INTEIRO;
 i = 1;
 total.entradas = total.válidas = 0;
 soma=0;
 DO WHILE valor[i] <> -999 and total.entradas < 100
 incremente total.entradas de 1;
 Se valor[i] >= mínimo AND valor[i] <=máximo
 THEN incremento total.validas de 1;
 soma = soma + valor[i]
 ELSE pule
 ENDIF
 incremente i de 1;
 ENDDO
 IF total.validas>0
 THEN média = soma /total.validas;
 ELSE média = -999;
 ENDIF
END média
*
*
*
Derivando Casos de Teste 
PROCEDURE média;
INTERFACE RETORNA média, total.entradas, total.validas;
 INTERFACE ACEITA valor, mínimo, máximo;
 TIPO valor[1:100] É VETOR DE ESCALA;
 TIPO média, total.entradas, total.válidas;
 mínimo, máximo, soma é ESCALA;
 TIPO i É INTEIRO;
 i = 1;
 total.entradas = total.válidas = 0;
 soma=0;
 DO WHILE valor[i] <> -999 and total.entradas < 100
 incremente total.entradas de 1;
 Se valor[i] >= mínimo AND valor[i] <=máximo
 THEN incremento total.validas de 1;
 soma = soma + valor[i]
 ELSE pule
 ENDIF
 incremente i de 1;
 ENDDO
 IF total.validas>0
 THEN média = soma /total.validas;
 ELSE média = -999;
 ENDIF
END média
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13
Usando o projeto ou código como base, trace um grafo de fluxo correspondente.
*
*
*
Derivando Casos de Teste (cont.) 
2. Determine a complexidade ciclomática do grafo do fluxo resultante.
V(G) = 6 regiões
V(G) = 17 ramos – 13 nós + 2 = 6
V(G) = 5 nós predicativos + 1 = 6
1
2
3
4
5
6
7
8
9
10
11
12
13
r1
r2
r3
r4
r5
r6
*
*
*
Derivando Casos de Teste (cont.) 
3. Determine um conjunto básico de caminhos linearmente independentes.
O valor de V(G) fornece o número de 
Caminhos linearmente independentes.
Caminho 1: 1-2-10-11-13
Caminho 2: 1-2-10-12-13
Caminho 3: 1-2-3-10-11-13
Caminho 4: 1-2-3-4-7-8-9-2...
Caminho 5: 1-2-3-4-5-7-8-9-2...
Caminho 6: 1-2-3-4-5-6-8-9-2...
 (...) qualquer caminho ao longo do restante da
 Estrutura de controle é aceitável. 
Nós predicativos auxiliam da derivação dos
 Casos de teste (2,3,4,5,10).
1
2
3
4
5
6
7
8
9
10
11
12
13
r1
r2
r3
r4
r5
r6
*
*
*
Derivando Casos de Teste (cont.) 
4. Prepare os casos de teste que forcem a execução de cada caminho no conjunto básico. 
Caminho 1: 1-2-10-11-13
Casos de Teste
valor(i) = entrada válida, i< -999
Resultados Esperados:	
médias corretas baseadas	
em i valores e totais apropriados.
* Devem ser testados como
parte dos testes dos caminhos 4, 5, 6. 
Não podem ser testados isoladamente!
1
2
3
4
5
6
7
8
9
10
11
12
13
PROCEDURE média;
INTERFACE RETORNA média, total.entradas, total.validas;
INTERFACE ACEITA valor, mínimo, máximo;
 TIPO valor[1:100] É VETOR DE ESCALA;
 TIPO média, total.entradas, total.válidas;
 mínimo, máximo, soma é ESCALA;
 TIPO i É INTEIRO;
 i = 1;
 total.entradas = total.válidas = 0;
 soma=0;
 DO WHILE valor[i] <> -999 and total.entradas < 100
 incremente total.entradas de 1;
 Se valor[i] >= mínimo AND valor[i] <=máximo
 THEN incremento total.validas de 1;
 soma = soma + valor[i]
 ELSE pule
 ENDIF
 incremente i de 1;
 ENDDO
 IF total.validas>0
 THEN média = soma /total.validas;
 ELSE média = -999;
 ENDIF
END média
*
*
*
Derivando Casos de Teste (cont.) 
Caminho 2: 1-2-10-12-13
Casos de Teste
valor(1) = - 999
Resultados Esperados:	
média = - 999	
Caminho 3: 1-2-3-10-11-13
Casos de Teste 
Tente processar 101 ou mais valores
Primeiros 100 valores devem ser válidos.
Resultados Esperados: idem 1
PROCEDURE média;
INTERFACE RETORNA média, total.entradas, total.validas;
 INTERFACE ACEITA valor, mínimo, máximo;
 TIPO valor[1:100] É VETOR DE ESCALA;
 TIPO média, total.entradas, total.válidas;
 mínimo, máximo, soma é ESCALA;
 TIPO i É INTEIRO;
 i = 1;
 total.entradas = total.válidas = 0;
 soma=0;
 DO WHILE valor[i] <> -999 and total.entradas < 100
 incremente total.entradas de 1;
 Se valor[i] >= mínimo AND valor[i] <=máximo
 THEN incremento total.validas de 1;
 soma = soma + valor[i]
 ELSE pule
 ENDIF
 incremente i de 1;
 ENDDO
 IF total.validas>0
 THEN média = soma /total.validas;
 ELSE média = -999;
 ENDIF
END média
1
2
3
4
5
6
7
8
9
10
11
12
13
*
*
*
Derivando Casos de Teste (cont.) 
Caminho 4: 1-2-3-4-7-8-9-2...
Casos de Teste
valor(i) = entrada válida, i < 100 
valor(i) < minimum
Resultados Esperados:
média correta baseada em
i valores e totais apropriados.
Caminho 5: 1-2-3-4-5-7-8-9-2... 
Casos de Teste
valor(i) = entrada válida, i < 100 
valor(i) >= minimum
valor(i) > maximum
Resultados Esperados:
média correta baseada em
i valores e totais apropriados.
PROCEDURE média;
INTERFACE RETORNA média, total.entradas, total.validas;
 INTERFACE ACEITA valor, mínimo, máximo;
 TIPO valor[1:100] É VETOR DE ESCALA;
 TIPO média, total.entradas, total.válidas;
 mínimo, máximo, soma é ESCALA;
 TIPO i É INTEIRO;
 i = 1;
 total.entradas = total.válidas = 0;
 soma=0;
 DO WHILE valor[i] <> -999 and total.entradas < 100
 incremente total.entradas de 1;
 Se valor[i] >= mínimo AND valor[i] <=máximo
 THEN incremento total.validas de 1;
 soma = soma + valor[i]
 ELSE pule
 ENDIF
 incremente i de 1;
 ENDDO
 IF total.validas>0
 THEN média = soma /total.validas;
 ELSE média = -999;
 ENDIF
END média
1
2
3
4
5
6
7
8
9
10
11
12
13
*
*
*
Derivando Casos de Teste (cont.) 
Caminho 6: 1-2-3-4-5-6-8-9-2...
Casos de Teste
valor(i) = entrada válida, i < 100 
Resultados Esperados:	
média correta baseada em 	
i valores e totais 	
apropriados. 
1
2
3
4
5
6
7
8
9
10
11
12
13
PROCEDURE média;
INTERFACE RETORNA média, total.entradas, total.validas;
 INTERFACE ACEITA valor, mínimo, máximo;
 TIPO valor[1:100] É VETOR DE ESCALA;
 TIPO média, total.entradas, total.válidas;
 mínimo, máximo, soma é ESCALA;
 TIPO i É INTEIRO;
 i = 1;
 total.entradas = total.válidas = 0;
 soma=0;
 DO WHILE valor[i] <> -999 and total.entradas < 100
 incremente total.entradas de 1;
 Se valor[i] >= mínimo AND valor[i] <=máximo
 THEN incremento total.validas de 1;
 soma = soma + valor[i]
 ELSE pule
 ENDIF
 incremente i de 1;
 ENDDO
 IF total.validas>0
 THEN média = soma /total.validas;
 ELSE média = -999;
 ENDIF
END média
*
*
*
2.3. Teste de Estrutura de Controle
 Técnica de teste de caminho básico é uma dentre uma série de técnicas de teste de estrutura de controle.
 Embora o teste do caminho básico seja simples e altamente efetivo, não é suficiente por si só.
 Veremos outras variações de teste de estrutura 
 de controle que ampliam a cobertura dos testes
 e melhoram a qualidade do teste de caixa branca.
*
*
*
2.3.1 Teste de Condição
Método de Projeto de casos de teste que põe à prova as condições lógicas contidas num módulo de programa.
 Condição Simples: variável booleana ou expressão relacional, possivelmente precedida por um operador NOT (‘)
 Expressão Relacional: E1<operador relacional>E2, onde E1 e E2 são expressões aritméticas e <operador relacional> pode ser: <, <=, =, <>, > ou >=.
 Condição Composta: duas ou mais condições simples, operadores booleanos e parênteses.
 Operadores booleanos: OR (|), AND (&) e NOT (‘).
Condições sem expressões relacionais: expressão booleana.
 
*
*
*
2.3.1 Teste de Condição (cont.)
 Possíveis tipos de componentes de uma condição: operador booleano, variável booleana, par de parênteses booleano (ao redor de condição simples ou composta), operador relacional ou uma expressão aritmética.
 Se condição incorreta  pelo menos um de seus					 componentes incorretos
			 
			 
 Tipos de Erros de uma Condição: erro de operador booleano, erro de variável booleana, erro de parênteses booleano, erro de operador relacional, erro de expressão aritmética.
 O propósito do teste de condição é detectar não somente erros nas condições de um programa, mas também outros erros.
*
*
*
2.3.1 Teste de Condição (cont.)
Teste de Ramos: Para uma condição C composta, os ramos verdadeiro e falso de C e todas as condições simples em C precisam ser executadas pelo menos uma vez.
*
*
*
2.3.1 Teste de Condição (cont.)
Teste de Domínio: requer 3 ou 4 testes sejam derivados para uma expressão relacional.
Para uma expressão relacional da forma: 
E1 <operador relacional> E2
3 testes são exigidos para tornar o valor de E1 >, = ou < que o de E2.
Se <operador relacional> estiver incorreto e E1,E2 corretos, esses 3 testes garantem a detecção de erro de operador relacional.
Para detectar erros em E1 e E2, basta executar um teste que faça o valor de E1 > ou < que o de E2, com uma diferença menor possível.
*
*
*
2.4 Teste de Laços (loops)
 Laços  Fundamental para a grande maioria de todos os algoritmos implementados no software.
 Teste de Laços: técnica de teste de caixa branca que concentra exclusivamente na validade das construções de laços.
 Laços Simples: deve ser aplicado o seguinte conjunto de teste: (sabe-se que n=número máximo de passagens permissíveis através do laço)
 	
	- Pule o laço inteiramente;
	- Somente uma passagem através do laço;
	- Duas passagens através do laço;
	- m passagens através do laço, onde m < n;
	- n-1, n, n+1 passagens através do laço.
*
*
*
2.4 Teste de Laços (cont.)
 Laços Aninhados: Beizer sugere a seguinte abordagem:
	1. Inicie pelo laço mais interno. Fixe os laços em 	valores mínimos.
	2. Realize testes de laços simples para o laço mais 	interno.
	3. Trabalhe para fora, realizando testes para o laço 	seguinte.
	4. Continue até que todos os laços tenham sido 	testados. 
*
*
*
2.4 Teste de Laços (cont.)
 Laços Concatenados: 
	1. se laços independentes dos demais 
			usar abordagem de laços simples.
	2. Se contador de laços para o laço 1
	 for usado como valor inicial para o laço 2  
		 usar abordagem de laços aninhados. 
 Laços não-estruturados: sempre que possível, 
esta classe deve ser reprojetada para refletir o uso
das construções de programação estruturada.