UESA Testes de Software Aula 2 MAR 2014 OK Final

Prévia do material em texto

Testes de Software
INF-0524
Prof. Jose Guilherme
2011.1
Técnicas de Teste de SW
– Projeto de casos de teste: qualquer produto pode ser 
testado de duas maneiras:
• Conhecendo-se a função específica que um produto projetado 
deve executar, testes podem ser realizados para demonstrar 
que cada função é totalmente operacional (teste de caixa 
preta - “black box”)
• Conhecendo-se o funcionamento interno de um produto, 
testes podem ser realizados para garantir que “todas as 
engrenagens”, ou seja, que a operação interna de um produto 
tem um desempenho de acordo com as especificações e que 
os componentes internos foram adequadamente postos à
prova (teste de caixa branca - “white box”)
Projeto de casos de teste
– Teste de caixa preta refere-se aos testes realizados nas 
interfaces do SW (a entrada é adequadamente aceita e a 
saída é corretamente produzida e que a integridade das 
informações externas é mantida).
– Teste de caixa branca baseia-se num minucioso exame 
dos detalhes procedimentais, através da definição de todos 
os caminhos lógicos possíveis. Infelizmente estes testes 
apresentam problemas logísticos, uma vez que o número 
destes possíveis caminhos lógicos pode ser muito grande, o 
que levaria a um tempo infinito. Entretanto este tipo de teste 
não pode ser desprezado como pouco prático, podendo-se 
optar por um número limitado de opções.
– Os atributos de ambos os testes podem ser combinados 
para oferecer uma abordagem que valide a interface com o 
SW e garanta seletivamente que o funcionamento interno 
do SW esteja correto.
Técnicas de Teste de SW
• Teste de caixa branca: usa a estrutura de controle do 
projeto procedimental para derivar casos de teste, 
podendo derivar casos de teste que:
– garantam que todos os caminhos independentes dentro de um 
módulo tenham sido exercitados pelo menos uma vez;
– exercitem todas as decisões lógicas para valores falsos ou 
verdadeiros;
– executem todos os laços em suas fronteiras e dentro de seus 
limites operacionais; e
– exercitem as estruturas de dados internas para garantir a sua 
validade.
Teste de caixa branca
• Teste de caminho básico: é uma técnica de teste de 
caixa branca que possibilita que o projetista do caso 
de teste derive uma medida de complexidade lógica 
de um projeto procedimental e use essa medida 
como guia para definir um conjunto básico de 
caminhos de execução. Os casos de teste derivados 
para exercitarem o conjunto básico tem a garantia de 
executar cada instrução do programa pelo menos 
uma vez durante a atividade de teste.
– Notação de grafo de fluxo: é uma notação simples para a 
representação do fluxo de controle, que descreve o fluxo 
lógico:
Sequência
IF WHILE CASE
Seqüência
If
while
case
Notação de grafo de fluxo
Teste de Caminho Básico 
• Possibilita que o projetista do caso de teste 
derive uma medida da complexidade lógica do 
projeto procedimental.
• Usa essa medida como guia para definir um 
conjunto básico de caminhos de execução.
• Os casos de teste derivados para exercitarem o 
conjunto básico têm a garantia de executar cada 
instrução do programa pelo menos uma vez 
durante a atividade de teste. 
Complexidade Ciclomática (CC) 
• Métrica de software que proporciona uma 
medida quantitativa da complexidade lógica 
de um programa. 
• Quando usado no contexto do método de 
teste do caminho básico, o valor computado 
da Complexidade Ciclomática define o 
número de caminhos independentes do 
conjunto básico de um programa e oferece 
um limite máximo para o número de testes 
que deve ser executado para garantir que 
todas as instruções sejam executadas pelo 
menos uma vez. 
Complexidade Ciclomática (CC)
• A idéia é basicamente é contar o número de caminhos 
diferentes que um método pode ter.
• A CC (também chamada de complexidade condicional) é uma 
métrica para determinar o quão complexo é um programa.
• Encontrar o nº de caminhos não é tão fácil, um algoritmo muito 
conhecido é a Complexidade de McCabe - Complexidade 
Ciclomática - foi definida por Thomas McCabe (1975 / 1976).
• Esta, basicamente, conta o número de vezes que um for, 
while, instruções if, case (do switch), catch, &&, || ou
aparecem.
• Além disso, todo método tem seu contador já inicializado com
1 !!!!
• Afinal, todo método tem pelo menos um caminho. 
• Não há um número ideal para a complexidade de um método.
• Mas, uma CC de 20 ou 30 já é alta e esse método deve ser 
reescrito
Complexidade Ciclomática (CC)
• A Complexidade Ciclomática há duas formas de 
se calcular: 
• Pela construção do grafo do algoritmo; e 
• Pela contagem de condicionais e loops
Complexidade Classificação
Entre 1 e 10 Baixa complexidade. Fácil 
entender e testar.
Entre 11 e 20
Média complexidade. 
Relativamente difícil 
entender e testar.
Entre 21 e 50 Alta complexidade. Difícil 
entender e testar.
Maior que 51 Altíssima complexidade. Impossível entender e testar.
CC
Probabilidade de 
efeitos colaterais
1-10 5%
20-30 20%
>50 40%
aprox. 100 60%
Complexidade Ciclomática (CC)
• A CC define-se como o somatório de todas as decisões 
acrescido de 1.
• Complexidade Ciclomática Extendida ���� CC2
• A CC2 não é mais que a extensão da CC por adição dos 
operadores booleanos.
• CC2 = CC + Número de operadores booleanos
• Entenda-se por decisão todas operações condicionais:
Operação Efeito no CC
if +1
else if +1
else 0
select case +1 para cada caso
select default 0
for/foreach +1
do while +1
do 0
while +1
catch +1
Complexidade Ciclomática (CC)
Complexidade Ciclomática (CC)
Complexidade Ciclomática (CC)
Complexidade Ciclomática (CC)
1
2,3
6
7 8
9
4,5
10
11
nó
ramo
R1
R2R3
R4
Região
Complexidade Ciclomática
Teste do Caminho Básico
Complexidade Ciclomática
• Um 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. Quando estabelecido em termos 
de um grafo de fluxo, um caminho independente 
deve incluir pelo menos um ramo que não tenha sido 
atravessado antes que o caminho seja definido. Por 
exemplo, um conjunto de caminhos independentes, 
referentes à figura anterior:
•caminho 1: 1-11
•caminho 2: 1-2-3-4-5-10-1-11
•caminho 3: 1-2-3-6-8-9-10-1-11
•caminho 4: 1-2-3-6-7-9-10-1-11
Notação de Grafo de Fluxo
Exemplo: Segmento de linguagem de projeto e seu
correspondente grafo de fluxo.
procedure:sort
do while records remain
read record;
if record field1 = 0
then process record;
store in buffer;
increment counter;
elseif record field2 = 0
then reset counter;
else process record;
store in file;
endif
enddo
end
•1:
•2:
•3:
•4:
•5:
•6:
•7a:
•7b:
•8:
1
2
4
6 5
7a
3
7b
8
Condições Compostas: um ou mais operadores booleanos
(OR, AND, etc) 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 constitui
um NÓ PREDICATIVO: contém uma condição e é caracterizado por 2 ou +
ramos saindo dele.
Nó predicativo
X
X
Y
B
A
Notação de Grafo de Fluxo
Complexidade Ciclomática
� 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.1
2,3
6
7 8
9
4,5
10
11
nó
ramo
R1
R2R3
R4
Região
Exemplo: 
1. V(G) = 4 regiões
2. V(G) = 11 ramos – 9 nós + 2 = 4
3. V(G) = 3 nós predicativos + 1 = 4
Complexidade Ciclomática
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;
IF 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
Complexidade Ciclomática
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;
IF 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
910
1112
13
1
2
3
4
5
6
78
9
10
1112
13
Usando o projeto ou código como base, trace um grafo de fluxo 
correspondente.
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
78
9
10
1112
13
r1
r2
r3
r4
r5
r6
Derivando Casos de Teste
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 na derivação dos
Casos de teste (2,3,4,5,10).
1
2
3
4
5
6
78
9
10
1112
13
r1
r2
r3
r4
r5
r6
Derivando Casos de Teste
Derivando Casos de Teste
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!
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;
IF 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
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
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;
IF 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
910
11
12
13
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.
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;
IF 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
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.
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;
IF 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