03-testescxbranca

Testes de Software

Testes baseados na implementação

(fluxo de controle)

criado: setembro/2001 atualizado: abril/2002

Tópicos

• O que é

• Grafo de fluxo de controle

• Critérios de cobertura

Referências

B.Beizer. Software Testing Techniques. International Thomson Computer Press, 2ª ed, 1990.

R.Binder. Testing OO Systems. Addison Wesley, 2000

E.Martins, Verificação e Validação de Software. Notas de Curso. G.J.Myers. The Art of Software Testing. John Wiley & Sons, 1979.

W. de Pádua Paula Fº. Engenharia de Software. Ed. LTC, 2ª edi., 2002. R.S.Pressman. “Software Engineering. A Practitiner’s Approach”. 4ª

edição, 1997.

Atividades

Planejamento Projeto Implementação Execução Verificação de Término Manutenção Balanço Final

determinar objetivos dos testes (o que testar?)

determinar estratégia para criar os testes que atendam aos objetivos

Introdução

• Testes baseados na implementação ou testes caixa-branca:

– são baseados no código

– visam exercitar estruturas de controle (instruções) e de dados de um programa

• Modelos de teste:

– grafo de fluxo de controle – grafo de fluxo de dados

Grafo de fluxo de controle

nó = bloco de comandos seqüenciais

aresta ou ramo = transferência de controle

1

1

2

3

4

1

2

3

m

n

...

1

2

3

1

2

3

bloco seqüencial

seleção

if-then-else _case

repetição

while repeat-until

Exemplo

Cálculo de xy 1. read x, y; 2. if y < 0 3. then p := 0 - y 4. else p := y; 5. z := 1.0; 6. while p _{≠ 0 do} 7. begin z := z * x; p := p - 1; end; 8. if y < 0 9. then z := 1 / z; 10. write z; end;

1

2

3

₄

5

6

7

8

9

10

y < 0 _{y ≥ 0} p _{≠ 0} y < 0 y _{≥ 0}

Critérios de cobertura

• Objetivos:

– geração de testes: determinação dos dados de teste – avaliação final: indicação de término dos testes

• Tipos:

– cobertura de instruções – cobertura de decisões – cobertura de condições – cobertura de caminhos

Testes de instruções

1

2

3

₄

5

6

7

8

9

10

y < 0 y _{≥ 0} p _{≠ 0} y < 0 y _{≥ 0}

Critério: cada instrução deve ser executada pelo menos 1 vez

nós predicados dados

{1,2,3,5,6,7,8,9,10} _{∀x, y < 0} (4, -1)

Testes de instruções

1

2

3

4

5

₆

x par x ímpar x < 0 _{x ≥ 0} nós predicados dados {1,2,3,4,5} x par negativo -2 {1,2,3,4,6} x par positivo 2

L note que o ramo 2 → 4 não é exercitado

read x; y := 0; y := x; write y; write y; y := y + x / 2;

Testes de decisões

1

2

3

₄

5

6

7

8

9

10

y < 0 _{y ≥ 0} p _{≠ 0} y < 0 y _{≥ 0}

Critério: cada ramo deve ser percorrido pelo menos 1 vez

ramos predicados dados

{(1,2), (2,3), (3,5), (5,6) _{∀x, y < 0} (4, -1) (6,7), (7,6), (6,8), (8,9), (9,10)}

{(1,2), (2,4), (4,5), (5,6), _{∀x, y = 0} (4, 0)

c

Teste de decisões

1. if a >= 0 and a <= 200 2. then m := 1 3. else m := 3 4. ...

1

2

3

4

c

_{¬ c}

ramos dados {(1,2), (2,4)} a = 5

{(1,3), (3,4)} a = -5

L o critério é satisfeito mas o erro

_{não é detectado}

Teste de decisões/condições

1. if a >= 0 and a <= 200 2. then m := 1 3. else m := 3 4. ...

c

₁

2

3

4

ramos dados {(1,1A), (1A, 2), (2,4)} a = 200 {(1,1A), (1A,3), (3,4)} a = 500 {(1,3), (3,4)} a = -5

Critério: todas as condições devem ser

testadas para valores V e F em cada decisão

1A

a _{≥ 0 a < 0}

Testes de caminhos

• Dificuldades:

– executabilidade: nem todos os caminhos no grafo são executáveis pelo programa

– grafos com ciclos: nº de caminhos pode ser indeterminado ou infinito ò

– necessidade de critérios que permitam limitar o nº de caminhos:

• testes de caminhos básicos • testes de laços

Critério: todos os caminhos possíveis do

Testes de caminhos básicos

• Em vez de todos os caminhos, busca os caminhos independentes:

– Caminho independente: contém pelo menos 1 nova aresta do grafo de controle

– O nº de caminhos independentes é dado pela complexidade ciclomática (V(G)) de McCabe:

V(G) = nº de predicados + 1

– Uma vez que todos os outros caminhos do grafo são combinações dos caminhos independentes _{Þ V(G) é o limite inferior do nº de testes de} caminhos

Testes de caminhos básicos

1

2

3

₄

5

6

7

8

9

10

y < 0 _{y ≥ 0} p _{≠ 0} y < 0 y _{≥ 0}

Critério: cada caminho independente deve ser percorrido pelo menos 1 vez

caminhos predicados dados

{1-2-4-5-6-8-10} _{∀x, y = 0} (4, 0)

{1-2-4-5-6-7-6-8-10} _{∀x, y > 0} (4, 6) {1-2-3-5-6-7-6-7-8-10} _{∀x, y ??} ?? {1-2-3-5-6-7-6-7-8-9-10} _{∀x, y < 0} (4, 6)

Limitação da V(G) para medir nº de testes

...

case A of

“um”

_{Þ i := 1}

“dois”

_{Þ i := 2}

“tres”

_{Þ i := 3}

“quatro”

_{Þ i := 4}

end case;

...

cadeia: array [1 .. 4] of

string (6) := ( “um”,

“dois”, “tres”, “quatro” );

i := 1;

while cadeia( i )

_{≠ A do}

i := i + 1

end while;

V(G) = 5 V(G) = 2 (case _{≡ if ’s aninhados)}

Teste de laços

• Procedimento:

 pule o laço

‚ passe pelo laço 1 vez

ƒ passe pelo laço m vezes, onde m < max „ passe pelo laço max-1 vezes

… passe pelo laço max vezes

† tente passar pelo laço max+1 vezes

Teste de laços

• Procedimento:

 comece pelo laço mais interno. Fixe os outros nos valores mínimos

‚ realize testes para laços simples

ƒ caminhe para fora, realizando testes no laço seguinte e mantendo os demais nos valores mínimos

„ continue até que todos tenham sido testados

Teste de laços

• Procedimento:

 se os laços são independentes, trate-os como laços simples

‚ se valor final do contador do laço anterior é usado como valor inicial do próximo, trate-os como laços

aninhados

Teste de laços

• Procedimento:

 estrutrá-los primeiro

‚ tratá-los segundo um dos casos anteriores

Exercício 1 - Rotina para busca binária

Entradas: tabela, item, chave Saídas: achou, onde

comeco := 1;

fim := Tamanho_tabela; achou := falso;

while comeco _{≤ fim and not achou do}

meio := (comeco + fim) / 2; if chave > tabela [meio]

then comeco := meio + 1 else if chave = tabela [meio]

then achou := verdade;

onde := meio

else fim := meio - 1 end while;

Exercício 2

Entradas: x1, x2, x3: inteiros; x4: char Saídas: w, x1 if x1 > x2 then w := 100 else w := 10; while x1 > x3 do x3 := x3 * w end while; case x4 “A” - “J”: w := 10 “K” - “T”: w := 20 “U” - “Z”: w := 30 end case; if x2 > x1 and x2 < x3 and x4 = “S” then w := 10 else w := 20; if x1 < w or x2 < w then write w else write x1;

Sumário

• Testes caixa branca:

– são úteis para completar testes caixa preta:

• completar conjunto de testes para que no mínimo todas as instruções sejam cobertas

– permitem detectar código inútil

– oferecem dificuldade para determinação dos dados que exercitem elementos requeridos pelo critério de cobertura:

• existência de caminhos não executáveis • complexidade dos predicados de caminhos

– requerem ferramenta que analise cobertura dos testes para que seja aplicado de forma eficiente