Testes de Regressão Criado: jun/2001 Atualizado: nov/2009.

Apresentação em tema: "Testes de Regressão Criado: jun/2001 Atualizado: nov/2009."— Transcrição da apresentação:

1 Testes de Regressão Criado: jun/2001 Atualizado: nov/2009

2 Tópicos Conceito Classificação Tipos de técnicas
Características desejáveis das técnicas Ferramentas 2

3 Referências R. Binder. “Testing OO Systems: Models, Patterns and Tools”. Addison- Wesley, 1999, c.15. G.Rothermel, M.J.Harrold. “A Framework for Evaluating Regression Test Selection Techniques”, Proc. 16th. Int’l Conf on Sw Eng., Sorrento, Itália, maio/1994, pg M.J.Harrold. “Testing Evolving Software”. The Journal of Systems and Sw, nº 47, 1999, pp L.A Fondazzi Martimiano. “Estudo de Técnicas de Teste de Regressão Baseado em Mutação Seletiva”. Dissertação de mestrado. Instituto de Ciências Matemáticas e de Computação - USP/S.Carlos, 1999. 3

4 O que é Testes realizados a cada vez que um sw é alterado Objetivo:
validar modificações feitas mostrar que modificações realizadas não afetaram as partes que não foram modificadas isto é mostrar que o sw não regrediu 4

5 Teste de Regressão Objetivo: verificar Impacto de Mudanças

6 Alguns conceitos Linha básica (“baseline”) Delta
versão de um componente (ou sistema) já testada Delta modificação feita a um componente (ou sistema) e que ainda não foi testada Configuração delta (“delta build”) configuração executável do sistema contendo deltas e linhas básicas Caso de teste de regressão caso de teste aplicado à linha de base com veredicto = passou se veredicto = não passou na config. delta  falha de regressão Testes aplicados a um componente novo ou modificado não são suficientes para nos dar confiança no sistema que contém o componente, mesmo que este sistema tenha sido adequadamente testado pois: - um componente novo/modificado pode não funcionar corretamente quando em conjunto com o restante dos componentes do sistema, - um componente novo/modificado pode causar efeitos colaterais em outros componentes não modificados Diz-se então que o sistema regrediu. Os testes de regressão visam determinar se tal não aconteceu. Termos [R.Binder99]: linha básica; delta; configuração delta; caso de teste de regressão (testes aplicados à linha básica com veredicto=passou e que espera-se que a configuração delta tb. Passe); seq de testes de regressão (composta de casos de testes de regressão); falha de regressão (revelada por um caso de teste de regressão que “não passa” na config delta). 6

7 Quando aplicar Para testar aplicações críticas que devem ser retestadas freqüentemente Para testar sw que é alterado constantemente durante o desenvolvimento (ex.: Processo Incremental ou Evolutivo) Para testar componentes reutilizáveis para determinar se são adequados para o novo sistema Durante os testes de integração Durante os testes, após correções Em fase de manutenção (corretiva, adaptativa, perfectiva ou preventiva) Para identificar diferenças no comportamento do sistema quando há mudanças de plataforma (uso de seqüências-padrão ou “benchmarks”) Testes de regressão devem ser usados: - para testar aplic. Críticas que devem ser retestadas com freqüência [Harrold99] - para testar sistemas que são desenvolvidos de forma rápida e incremental, e que portanto são alterados constantemente (Proc. Increm., Extreme Programming são exemplos desse tipo de situação) - no desenv baseado em reuso de componentes. Nesse caso é recomendável utilizar a seq de testes usadas pelo fornecedor do componente a cada reuso do mesmo - durante os testes de integração os sistemas. Neste caso a seq de testes de regressão pode ir sendo construída incrementalmente - durante os diferentes tipos de manutenção do sw - para determinar se há mudanças no comportamento de um sistema quando há mudança de plataforma. Em alguns casos existem seq de testes padronizadas (benchmarks), que neste caso não são necessariamente voltadas para revelar falhas de regressão. 7

8 Quando aplicar (OO) Quando uma nova subclasse é criada
Quando uma super-classe é alterada Quando uma classe servidora é alterada Quando uma classe é reutilizada em um novo contexto Apesar do alto potencial para reuso que a tecnologia OO apresenta, o uso de OO por si só não é capaz de evitar falhas de regressão. Para garantir um bom funcionamento de sistemas OO, testes de regressão são recomendados nas seguintes situações: - quando uma nova subclasse é criada: rodar testes de regressão (= testes da superclasse) + testes para a nova subclasse - quando a super-classe é alterada: reaplicar os testes da superclasse tanto na superclasse quanto nas suas subclasses - quando uma classe servidora é alterada: além de testar a classe alterada, reaplicar testes nas clientes para determinar se não houve efeitos colaterais 8

9 Limitações Uma seqüência de regressão NÃO contém testes para as partes novas ou alteradas Uma seqüência de testes que pode ser usada como seqüência de regressão deixa de ser útil como seqüência de testes primária Uma seqüência de regressão não tem as mesmas metas de cobertura de uma seqüência de testes primária O uso de seqüência de testes inadequada como seqüência de regressão não melhora sua qualidade - Seq de testes primária = seq de testes aplicada a uma linha básica e que tem por objetivo revelar falhas de construção/alteração Logo, quando seq de testes passa a ser usada como seq de regressão ela deixa de ser útil como seq de testes primária, pois a linha básica já “passou” nos testes que ela contém. - seq de regressão visam determinar se o sistema continua executando corretamente as partes inalteradas, portanto não tem como meta nenhuma cobertura de critérios - o uso de uma seq de testes primária inadequada (ie, com baixa cobertura) como seq de regressão não vai fazer com que sua qualidade (em termos de cobertura) melhore Apesar das limitações, seq de regressão são extremamente importantes para revelar falhas de regressão. A falha no Ariann5e, que causou um prejuízo de US$350 milhões (por baixo; estima-se que pode ter chegado a 2,5 bilhões), poderia ter sido revelada pelos testes de regressão! 9

10 Falhas de regressão - por quê?
Falhas de regressão ocorrem quando há dependências entre D (delta) e B (linha de base): de fluxo de controle de fluxo de dados restrições de ativação compartilhamento de dados tempo disputa por recursos 10

11 Modelos de falhas de regressão
Dados D(delta) e B (linha de base): D aloca / muda o valor / desaloca: variável global, atributo de uma classe, dado persistente usado por B, causando: (1) ativação de falha dormente em B ou (2) violação do contrato (pré-condições e invariantes) de B, gerando uma exceção ou (3) B viole contrato de outra linha de base B’ D é cliente de B e envia mensagem que viola contrato de B D é servidor de B e retorna valor que viola contrato de B D é incompatível com B ex.: precisão de valores reais entre D e B 11

12 Modelos de falhas de regressão (OO)
garante requer E B D garante cliente servidor requer E B D cliente servidor Contrato entre B e E não muda. D não é compatível com todos os contratos de E, mas pode substituí-la (polimorfismo) Contrato entre B e E não muda, mas comportamento de E muda devido à mudança em D 12

13 Processo Identificar modificações a P Modificar P  P’
Selecionar T’ T  partes novas, modificadas ou não testadas em P’? S Criar T’’ Testar P’ usando T’ Testar P’ usando T’’ N Seleção de testes de regressão no processo de manutenção [Harrold99]: 1. Identificar modificações a serem feitas em P (solicitação de manutenção e aprovação do pedido) 2. Modificar P obtendo P’ (atualização do sw, o que pode implicar na modificação de documentos e código) 3. Selecionar T’(seq. de regressão)  T (seq de testes de P): pb da seleção da seq de regressão, o que inclui a identificação de casos de teste de T que são obsoletos para P’. t T é obsoleto se t contém entrada que não está mais de acordo com especificação de P’ ou par entrada-saída em t é inválido para P’ 4. Testar P’ usando T’, o que inclui a depuração de P’ para os casos de teste de T’ que revelaram falhas 5. Se necessário criar T’’ contendo novos testes (cx branca ou preta) que cubram partes novas, modificadas ou não testadas  identificar porções de P’ (ou de sua especificação S’) que não foram cobertos por T’ (pb de identificação da cobertura) 6. Testar P’ com T’’ (inclui depuração e correção, como em 4) 7. Criar T’’’ = T  T’’  pb da manutenção de testes (atualização e armazenamento de infos de teste) e pb da minimização da seq de testes (remoção de testes obsoletos e redundantes) Criar T’’’ = T  T’’ Fim 13

14 Processo Pb da seleção da seqüência de regressão:
Identificar modificações a P Modificar P  P’ Selecionar T’ T Pb da seleção da seqüência de regressão: se t T obsoleto  não incluir t em T’ se t T’/ t exercita a modificação e T’ aplicado no mesmo contexto que T  T’ é segura (“safe”)  partes novas, modificadas ou não testadas em P’? S Criar T’’ Testar P’ usando T’ Testar P’ usando T’’ N Seleção de testes de regressão no processo de manutenção [Harrold99]: 1. Identificar modificações a serem feitas em P (solicitação de manutenção e aprovação do pedido) 2. Modificar P obtendo P’ (atualização do sw, o que pode implicar na modificação de documentos e código) 3. Selecionar T’(seq. de regressão)  T (seq de testes de P): pb da seleção da seq de regressão, o que inclui a identificação de casos de teste de T que são obsoletos para P’. t T é obsoleto se t contém entrada que não está mais de acordo com especificação de P’ ou par entrada-saída em t é inválido para P’ 4. Testar P’ usando T’, o que inclui a depuração de P’ para os casos de teste de T’ que revelaram falhas 5. Se necessário criar T’’ contendo novos testes (cx branca ou preta) que cubram partes novas, modificadas ou não testadas  identificar porções de P’ (ou de sua especificação S’) que não foram cobertos por T’ (pb de identificação da cobertura) 6. Testar P’ com T’’ (inclui depuração e correção, como em 4) 7. Criar T’’’ = T  T’’  pb da manutenção de testes (atualização e armazenamento de infos de teste) e pb da minimização da seq de testes (remoção de testes obsoletos e redundantes) Criar T’’’ = T  T’’ Fim 14

15 Processo Pb da cobertura:
Identificar modificações a P Modificar P  P’ Selecionar T’ T  partes novas, modificadas ou não testadas em P’? S Criar T’’ Testar P’ usando T’ Testar P’ usando T’’ Pb da cobertura: identificar partes de P’ (ou S’) que não foram cobertos N Seleção de testes de regressão no processo de manutenção [Harrold99]: 1. Identificar modificações a serem feitas em P (solicitação de manutenção e aprovação do pedido) 2. Modificar P obtendo P’ (atualização do sw, o que pode implicar na modificação de documentos e código) 3. Selecionar T’(seq. de regressão)  T (seq de testes de P): pb da seleção da seq de regressão, o que inclui a identificação de casos de teste de T que são obsoletos para P’. t T é obsoleto se t contém entrada que não está mais de acordo com especificação de P’ ou par entrada-saída em t é inválido para P’ 4. Testar P’ usando T’, o que inclui a depuração de P’ para os casos de teste de T’ que revelaram falhas 5. Se necessário criar T’’ contendo novos testes (cx branca ou preta) que cubram partes novas, modificadas ou não testadas  identificar porções de P’ (ou de sua especificação S’) que não foram cobertos por T’ (pb de identificação da cobertura) 6. Testar P’ com T’’ (inclui depuração e correção, como em 4) 7. Criar T’’’ = T  T’’  pb da manutenção de testes (atualização e armazenamento de infos de teste) e pb da minimização da seq de testes (remoção de testes obsoletos e redundantes) Criar T’’’ = T  T’’ Fim 15

16 Processo Pb da manutenção e minimização dos testes: atualizar T T’’’
Identificar modificações a P Modificar P  P’ Selecionar T’ T Pb da manutenção e minimização dos testes: atualizar T T’’’ minimizar T’’’: eliminar casos de teste redundantes e obsoletos  partes novas, modificadas ou não testadas em P’? S Criar T’’ Testar P’ usando T’ Testar P’ usando T’’ N Seleção de testes de regressão no processo de manutenção [Harrold99]: 1. Identificar modificações a serem feitas em P (solicitação de manutenção e aprovação do pedido) 2. Modificar P obtendo P’ (atualização do sw, o que pode implicar na modificação de documentos e código) 3. Selecionar T’(seq. de regressão)  T (seq de testes de P): pb da seleção da seq de regressão, o que inclui a identificação de casos de teste de T que são obsoletos para P’. t T é obsoleto se t contém entrada que não está mais de acordo com especificação de P’ ou par entrada-saída em t é inválido para P’ 4. Testar P’ usando T’, o que inclui a depuração de P’ para os casos de teste de T’ que revelaram falhas 5. Se necessário criar T’’ contendo novos testes (cx branca ou preta) que cubram partes novas, modificadas ou não testadas  identificar porções de P’ (ou de sua especificação S’) que não foram cobertos por T’ (pb de identificação da cobertura) 6. Testar P’ com T’’ (inclui depuração e correção, como em 4) 7. Criar T’’’ = T  T’’  pb da manutenção de testes (atualização e armazenamento de infos de teste) e pb da minimização da seq de testes (remoção de testes obsoletos e redundantes) Criar T’’’ = T  T’’ Fim 16

17 Abordagens Abordagens: retesta tudo: T’ = T seletiva: T’ T
qual abordagem usar? 17

18 Modelo custo x benefício
Sejam: | T | e | T’ | cardinalidades de T e T’ s custo médio de seleção/caso de teste r custo médio de execução/caso de teste se s  | T’ | < r  ( | T | - | T’ | )  regressão seletiva mas se potencial detecção falhas T’ < T  retesta tudo 18

19 Considerações para a seleção
Problema: segurança (safety) como obter T’ contendo casos de teste t  T que exercitem código de P que foi modificado em P’? Problema indecidível O uso de uma seqüência de regressão segura  todos os casos de teste que podem revelar a presença de falhas foram aplicados  ausência de falhas de regressão ou de qualquer outro tipo de falha Ideal: escolher T’ contendo todos os casos de teste de T que exercitem as partes modificadas em P que geraram P’. Qdo um caso de teste tem essa propriedade diz-se que ele percorre a modificação (modification-traversing). A dificuldade está em que escolher testes modification-traversing é um pb indecidível. As técnicas ditas seguras o são na verdade sob certas hipóteses. As técnicas baseadas no fluxo de controle inserem testes que cubram nós ou arcos de G. As técnicas baseadas em diferenças textuais são baseadas nas instruções fonte e usam “diff” e seleciona os testes associados aos nós onde haja modificações. As técnicas baseadas em entidades associam os testes de T com funções ou componentes não executáveis (por exemplo, áreas de dados) e seleciona os testes associados a entidades modificadas. As técnicas baseadas em fluxo de dados associam os testes em T com critérios baseados no fluxo de dados. São selecionados os testes de T que cobrem associações def-use que correspondem a partes do código que foram modificados. A técnica não é segura pois novos pares def-use originados de código inserido (ie, que não existia em P), não são considerados na seleção de T’. 19

20 Técnicas As técnicas de seleção de testes de regressão podem ser baseadas: No código Grafo de fluxo de controle Na arquitetura firewall Na especificação Casos de uso + seguras - seguras

21 Seleção baseada no código
Exemplo de técnica: Seleção baseada em segmento modificado As técnicas se baseiam na construção do Grafo de Fluxo de Controle (GFC) do programa Passeio síncrono no grafo original e no grafo modificado para identificar as modificações Será mostrado aqui somente o testes para GFC, pois a técnica é similar para o GFCC (de classes, que foi apresentado na aula de Grafo de Fluxo Interprocedimental).

22 Seleção para programas imperativos
Programa original P 1 GFC de P // função que calcula média de nros. // inteiros positivos lidos de um arquivo int M( ) 1. int n, conta = 0 2. int soma = 0 3. while (not EOF) do 4. fread (arq, n) 5. if (n < 0) return (-1) else soma += n conta++ endif printf (“passo: “, conta) endwhile 11. return (soma/conta) 2 3 V F 4 5 V F 7 6 8 9 11 10

23 Grafos de Fluxo de controle de P'
Programa modificado P’ GFC de P’ 1 // função que calcula soma de nros. // inteiros positivos lidos de um arquivo int M( ) 1. int n, conta = 0 2. int soma = 0 3. while (not EOF) do 4. fread (arq, n) 5. if (n < 0) 6a print (“entrada inválida”) return (-1) else soma += n conta++ endif >>> linha 10: eliminada endwhile 11. return (soma/conta) 2 3 V 4 F V 5 F 6a 7 6 8 11 9

24 Exemplo G T P testes caminho t1 ABDEFGHIX t2 ABDEGHIX t3 ABDHIX
V T P if A then B else C; if D then if E then F; G; if H then I; X; testes caminho t1 ABDEFGHIX t2 ABDEGHIX t3 ABDHIX t4 ACDHX 24

25 Seleção baseada no segmento modificado
X K H1 G F E D C’ A B V J H2 I L G’ G X I H F E D C A B V P’ if A then B else C’; if D then if E then F else J; G; if H1 then K else L; else if H2 then I; X; P if A then B else C; if D then if E then F; G; if H then I; X; Técnicas baseadas em entidades modificadas em geral tendem a selecionar todos os testes de T (granularidade + alta que instruções ou nós/arcos). Técnicas baseadas em instruções modificadas tb tendem a selecionar mais testes do que o necessário, mas a um custo menor. Técnicas baseadas no fluxo de controle tendem a selecionar menos testes, mas a um custo mais alto (algoritmos da fase de análise de T são mais complexos do que um diff). 25

26 Exemplo G’ T’ P’ if A then B Modificação seq. segura mínima else C’;
K H1 G F E D C’ A B V J H2 I L G’ T’ P’ if A then B else C’; if D then if E then F else J; G; if H1 then K else L; else if H2 then I; X; Modificação seq. segura mínima C  C’ t4 (ACDHX) + J t2 (ABDEGHIX) H  H1 + H2 t1 (ABDEFGHIX), t2 (ABDEGHIX), t3 (ABDHX), t4 (ACDHX) A tabela acima mostra um conjunto T’ seguro obtido a partir de um algoritmo de seleção baseado no fluxo de controle proposto por Harrold e Rothermel e implementado numa ferramenta chamada DejaVu (para programas em C) [ver Harrold99]. Resumidamente: o algoritmo associa casos de teste de T com arestas em G e seleciona o menor número possível de casos de teste baseado nas arestas. O algoritmo percorre G e G’ até encontrar arestas com rótulo igual mas com nós destino diferentes. Nesse ponto todos os casos de teste que passam por essa aresta em G são selecionados. No exemplo acima, ao percorrer o caminho ABDE em G e G’ o algoritmo detecta que para o arco rotulado como “F” em G é (E,G) e em G’ é (E, J), com G J  t2, que passa por (E, G), é incluído em T’. Para testar as mudanças em H (criação de H1 e H2), todos os testes de T seriam selecionados pelo algoritmo. No entanto o algoritmo de Ball, citado na mesma referência, selecionaria t1 e t2 para passar por H1 e H2. 26

27 Seleção para programas OO
Variante do algoritmo visto anteriormente onde se considera o Grafo de Fluxo de Controle Interprocedimental (GFCI) para representar a estrutura do código em C++ GFCI = GFC estendido: Nós de chamadas de funções (ou métodos) Nós de retorno Nós de entrada de função Nós de saída de função Arestas ligando estes nós

28 /* aleat.cpp * Exemplo de classe em C++ * Gerador de números aleatórios * O código baseia-se no exemplo encontrado em * / subjects/cpp/random.cpp ******/ #include <iostream.h> #include <conio.h> #include <math.h> #include <time.h> class GeraAleat { public: GeraAleat(void); void Init (double seed); double RAleat(void); int IAleat(void); void ObtemInterv(int min, int max); private: double ran; // ultimo nro aleat int rmin, rmax; // intervalo para IAleat }; // Construtor 1.GeraAleat::GeraAleat() { // inicializa seqüência com valor = hora local 2. Init (time(0));} // Inicializa seqüência aleatória // Essa função é chamada com um valor qqr // para iniciar uma nova seq de nros aleatórios 3. void GeraAleat::Init(double seed) { 4. rmin=0; rmax=1; // gera um valor decimal qqr 5. ran = seed * M_PI; // obtém dois valores da seq. 6. FRandom(); FRandom();} // gera nro real entre 0 e 1 7.double GeraAleat::RAleat(void) { 8. ran = fmod(ran* , 1.); 9. return ran;} // gera nro aleat inteiro dentro de um // intervalo dado por ObtemInterv 10.int GeraAleat::IAleat (void) { 11. int ir = rmin + RAleat()*(rmax-rmin+1); 12. if (ir > rmax) ir = rmax; 14. return ir;}// obtém intervalo para IAleat 15. void GeraAleat::ObtemInterv(int min, int max) { rmin = min; rmax = max;} // Programa exemplo mostrando como // gerar 20 nros aleat. 17. void main() { int i; 19. GeraAleat ga; 20. ga.ObtemInterv(0, 99); 21. for (i=0; i<20; i++) cout << "\n" << rg.IAleat(); 23. getch();}

29 I 17 18 19c 19r 20r 20c 21 23 22r 22c F 1 2c 2r 15 16 3 6 4 5 10 11c 11r 12 13 14 7 8 9

30 Seleção baseada na arquitetura
Uso de firewall O conceito de firewall foi introduzido por Leung e White (1989) para separar os módulos que podem ser afetados pelas modificações dos outros. Uma vez identificado o firewall,é selecionado um subconjunto de testes que exercitem os módulos dentro do firewall. A determinação do firewall se dá através da análise de dependências feita sobre o Grafo de Chamadas (GC) representando a hierarquia de uso de módulos de um sistema funcional.

31 Exemplo de um Grafo de Chamadas (GC)
B F G H E J K L I M N

32 Determinação do firewall
B C H E F G Especificação Código J K I K Módulo no firewall M N

33 Uso de firewall em software OO
Conjunto de componentes (classes, programas, módulos, ...) que devem ser incluídos nos testes de regressão Obtido através da análise de cada componente modificado e suas dependências com outros componentes Dependências entre A (delta) e B (linha de base): B usa A (B é cliente de A) B é servidor de A B é subclasse de A B sobrecarrega A (polimorfismo) [Binder99, c.15] 33

34 Exemplo - Reteste no firewall
Tem único  NroConta Tem  0 .. * Conta 2 .. * Usa ServiçodeFinanças  Aplicada a 0 .. * Usa Transação Dinheiro Oferecido através de  0 .. * Aplicada a  Taxas 34

35 Exemplo - Reteste no firewall
Dependências entre os componentes ServiçodeFinanças Transação Conta Taxas Dinheiro NroConta : depende de 35

36 Exemplo - Reteste no firewall
Seleção de Testes no Firewall Testes Transação ServiçodeFinanças Testes Conta firewall Transação Conta Taxas Dinheiro NroConta Testes Dinheiro —: inalterado —: modificado 36

37 Outro tipo de seleção baseada no firewall
Kung et al. (1995) propõem a definição de um firewall com base no Grafo de Relacionamentos entre Objetos (ORG, do inglês Object Relation Graph): Grafo orientado onde nós = classes e arestas são rotuladas de acordo com o relacionamento entre os objetos das classes que elas conectam: H: herança Ag: agregação As: associação

38 Obtenção de um ORG Diagrama de classes ORG

39 Determinação do firewall a partir do ORG
Pedido Conta Produto Linha de Empregado Pessoa Física Cliente Jurídica Ag As H Classe modificada

40 Técnicas baseadas na especificação
A seleção baseia-se na análise do modelo de especificação. No caso, utilizaremos técnicas baseadas nos casos de uso [Binder99, c.15] : Casos de uso de maior risco Casos de uso mais freqüentes

41 Seleção baseada nos casos de uso de maior risco
Faz-se uma análise de risco para identificar: Casos de uso críticos Aqueles que são cruciais para o bom funcionamento do sistema Casos de uso suspeitos Aqueles que dependem de recursos (componentes, hardware, software) pouco confiávis, ou seja, instáveis, pouco testados, mais complexos Selecionam-se os casos de teste para esses casos de uso

42 Matriz de rastreabilidade
... tM Caso de uso 1  Caso de uso 2 Caso de uso N

43 Seleção de acordo com o perfil operacional do caso de uso
Contexto: Recursos (equipamento, pessoal, conhecimento, tempo) para realização de testes de regressão são curtos o que fazer para selecionar subconjunto de testes da melhor maneira possível para os recursos disponíveis?  Alocar testes de acordo com a freqüência com que um caso de uso é realizado 43

44 Exemplo Supor que se dispõe de 100h (6000 min) para os testes de regressão de um ATM, dos quais: a execução de um caso de teste leva em média 5 min uma falha é revelada 0,5% do tempo a correção da falha requer em média 4h (240 min) Supor ainda que o conjunto de testes da linha básica contém casos de testes Quantos casos de testes devem ser selecionados? 44

45 Exemplo - Reteste de acordo com perfil
Seja T o total de testes que se quer realizar: 5T + (0,005T  240) = 6000  T  1000 Caso de Uso Freqüência Nº de testes Saque 50% Depósito 25% Transferência 12% Pede Saldo 8% Pede Extrato 3% Pede Talão 2% 45

46 Características de uma técnica de seleção
Inclusão o quanto a técnica inclui em T’ os casos de testes que fazem com que saída(P’)  saída(P) , revelando assim as falhas de regressão? Ex.: se | T | = 50 e 8 fazem com que saída(P’)  saída(P) se a técnica seleciona 2 destes 8 testes  a técnica tem uma inclusão de 25% com relação a P, P’ e T. para P, P’ e T quaisquer  pb indecidível Harrold e Rothermel determinaram critérios para avaliar técnicas de testes de regressão. 46

47 Características de uma técnica de seleção
Inclusão Precisão o quanto a técnica evita incluir em T’ os casos de teste que não farão com que saída(P’)  saída(P) ? Ex.: se | T | = 50 e 44 não fazem com que saída(P’)  saída(P) se a técnica não seleciona 33 destes 44 testes  a técnica tem uma precisão de 75% com relação a P, P’ e T. para P, P’ e T quaisquer  pb indecidível 47

48 Características de uma técnica de seleção
Inclusão Precisão Eficiência qual o custo computacional da técnica ? Espaço: quanto de informação o algoritmo necessita? Tempo: qual a complexidade do algoritmo de seleção? Fatores que influenciam na eficiência do algoritmo de seleção são [Harrold94]: - quantidade de informação que a técnica requer: se a técnica precisa determinar que elementos do programa foram modificados, suprimidos ou adicionados, ou precisa construir um mapeamento entre P e P’, esse método vai precisar de mais recursos computacionais do que um outro que não necessite dessas informações; - grau de automação da técnica 48

49 Características de uma técnica de seleção
Inclusão Precisão Eficiência Generalidade o quanto a técnica é genérica ? A técnica permite tratar qualquer tipo de modificação? A técnica pode tratar diferentes linguagens e tipos de programas? A técnica funciona tanto para unidade quanto para integração? 49

50 Características de uma técnica de seleção
Inclusão Precisão Eficiência Generalidade Suporte à cobertura o quanto a técnica permite que se obtenha cobertura com relação a algum critério ? Os critérios de cobertura usados para gerar T continuam sendo satisfeitos? A técnica permite que seja obtido T’’’ que cubra os acréscimos ou as modificações? 50

51 Ferramentas Testes manuais: Ferramentas que podem auxiliar:
não recomendável pois número de testes e nº de falhas  Ferramentas que podem auxiliar: Capture/playback: permitem armazenar e re-aplicar conjuntos de testes Controle de versões: controlar o sistema e seu histórico de testes Comparador de saídas: comparação entre resultados do delta e da linha básica Embaralhador de casos de teste: permitem revelar falhas de seqüência de entradas Testes embutidos: assertivas permitem revelar falhas de contrato. Drivers embutidos permitem reduzir custos com manutenção dos testes. Testes manuais são interessantes para situações específicas, mas não são recomendáveis como prática pois a medida em que manutenções são feitas, aumenta a complexidade e o número de falhas, bem como o nº de testes. Ferramentas de auxílio aos testes de regressão devem permitir: - armazenar casos de teste e controlar suas versões, da mesma forma que com o sistema; - comparar resultados da linha básica com resultados do delta. O comparador tem de ser “inteligente”, pois algumas vezes não faz sentido comparar as saídas. Por exemplo, se o sistema produz um “time stamp” que muda a cada execução não faz sentido. O que faz sentido é determinar, por exemplo, se o “time stamp” produzido é válido ou não. - embaralhador de casos de testes tb é útil para sistemas não modais, para determinar se o programa é sensível à ordem em que as entradas são fornecidas. - embutir assertivas e outros elementos de testes no componente facilita os testes de regressão. 51