Baixe o app para aproveitar ainda mais
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.
Compartilhar