SBMF 2008, Salvador-BA, Brasil Marcelo d'Amorim Fundamentos do Teste de Software

Motivação econômica Teste e depuração é responsável por + de 50% do custo total de desenvolvimento [Myers-1979, NIST-report-2002] Defeitos escapados podem ter consequências desastrosas Exemplo: Mars Orbiter (1999), Ariane 5 (2001)

Verificação e Validação (V&V) Theorem proving Static analysis Testing Inspection Walkthroughs

Verificação e Validação (V&V) Theorem proving Static analysis Testing Inspection Walkthroughs

Definição: Testes (processo) Atividade(s) de encontrar erros no software

Limitações Não prova corretude como theorem proving Não é automático como análise estática Porém... É técnica de V&V dominante na indústria Documenta intenções e designs Pode ser combinada com técnicas formais para encontrar erros de forma mais sistemática. Por exemplo, Kernel do Linux [Cadar et al., 2006], Protocolos de rede [d´Amorim et al., 2005], Escalonador de tempo real [Penix et al., 2000], etc.

Definição: Teste (artefato) “A set of test inputs, execution conditions, and expected results developed for a particular objective, such as to exercise a particular program path or to verify compliance with a specific requirement” [IEEE, do178b]

Definição: Teste (artefato) “A set of test inputs, execution conditions, and expected results developed for a particular objective, such as to exercise a particular program path or to verify compliance with a specific requirement” [IEEE, do178b]

Exemplo public class Customer { String getName() {…} } public class Bank{ static Bank createBank() {…} Customer createCustomer(String name) {…} }

Exemplo public class Customer { String getName() {…} } public class Bank{ static Bank createBank() {…} Customer createCustomer(String name) {…} } Bank bank = Bank.createBank(); String name = “customer1“; Customer cust = bank.createCustomer(name); Assert.assertEquals(name, cust.getName());

Exemplo public class Customer { String getName() {…} } public class Bank{ static Bank createBank() {…} Customer createCustomer(String name) {…} } Bank bank = Bank.createBank(); String name = “customer1“; Customer cust = bank.createCustomer(name); Assert.assertEquals(name, cust.getName()); Entrada e resultado esperado :

Exemplo public class Customer { String getName() {…} } public class Bank{ static Bank createBank() {…} Customer createCustomer(String name) {…} Customer search(String name) {…} } Bank bank = Bank.createBank(); String name = “customer1“; Customer cust = bank.search(name); if (cust == null) { Customer cust = bank.createCustomer(name); Assert.assertEquals(name, cust.getName()); } Condições de execução :

Terminologia: Falta e Falha IEEE STD ( ‏ Fault (falta, bug ou defeito) ‏ : problema Failure (falha, ou erro) ‏ : manifestação do problema Mais detalhes… Software Metrics and Reliability [Rosenberg et al., ISSRE’98]

Quiz: Localize falta e falha no pgm. abaixo // pre condicao: v != null public static void sort(int[] v) { for (int i = 0; i <= v.length; i++) { …v[i] … }

Quiz: Localize falta e falha no pgm. abaixo // pre condicao: v != null public static void sort(int[] v) { for (int i = 0; i <= v.length; i++) { …v[i] … } CAUSA EFEITO

Teste e Depuração Teste é atividade de localizar falhas! Depuração é atividade de localizar faltas!

Teste e Depuração Teste é atividade de localizar falhas! Depuração é atividade de localizar faltas! No exemplo anterior Atividade de teste revela um erro no uso de v[i]. E.g., com sort(new int[]{}); Depuração localiza o defeito na condição de parada do loop: i <= v.length

Terminologia: suíte e regressão Suíte de testes é o mesmo que conjunto de testes Regressão é o evento de uma falha em um teste que já passou Suíte de regressão serve para capturar falhas com origem na modificação contínua do programa

Enquete: Voce já usou? JUnit3 JUnit4 NUnit Ant Make

Agenda do curso Demo Junit (framework de testes) Testes no desenvolvimento Qualidade de suíte de testes Demo EclEmma (cálculo de cobertura) Demo MuClipse (cálculo de score de mutação) Automação da geração de testes Demo TARGET (geração baseada em modelos) Demo Randoop (geração aleatória)

Demo JUnit

Testes no desenvolvimento

Gerência de bugs (E.g., bugzilla) Teste contínuo

programadortestador gerente cliente alguns papéis

programadortestador gerente requisitos atribuição cliente

programadortestador gerente Bug tracker

Sistema de bug tracking Objetivo: gerenciar ciclo de vida de bugs Programadores e testadores modificam status de report Gerentes tem acesso a informação valiosa Exemplo: frequência de erro por módulo Exemplo: Bugzilla (open-source).

Máquina de estados de um bug no Bugzilla

Teste contínuo Execução ininterrupta de testes Alternativas Unidade (localmente) ver Sistema (no servidor) ver Problemas (mais críticos quando usado localmente) Pode impactar performance Pode reportar falso alarmes (devido a modificações incompletas)

Resumo Ferramenta de gerência de erros E.g., bugzilla, clearquest, etc. Ferramenta de integração contínua E.g., cruisecontrol, continuum, etc. Controle de versão E.g., cvs, svn, etc. Ferramenta de build E.g., ant, make, maven, etc.

Qualidade de suíte de testes

Problema Usuário não sabe quão adequada é uma suíte de testes para encontrar erro. Em resumo, como medir qualidade? Duas soluções Cobertura Score de Mutação

Definição: cobertura Valor que indica quanto uma suíte de testes cobre um programa de acordo com um critério particular Exemplo Cobertura de métodos indica o percentual de métodos de uma aplicação que um conjunto de testes exercita Princípio Maior cobertura aumenta chances de encontrar o erro

Simplificação didática Testar a estrutura de um programa equivale a testar um grafo

Control-Flow Graph (CFG) stmt0; while (condA){ if (condB){ stmt1; stmt2; } stmt3; } stmt4

Control-Flow Graph (CFG) stmt0; while (condA){ if (condB){ stmt1; stmt2; } stmt3; } stmt4 stmt0 condA stmt1; stmt2; stmt3 condB stmt4

Control-Flow Graph (CFG) stmt0 condA stmt1; stmt2; stmt3 condB stmt4 b c a f d e t0 t1t6 t2 t3 t4 t5

Quiz O que é uma sequência de teste para um grafo?

Quiz O que é uma sequência de teste para um grafo? Sequência de transições a partir do nó inicial que termina em uma folha

Cobertura de Grafos Exemplo de sequência de teste t0; t6 b c a f d e t0 t1t6 t2 t3 t4 t5

Critérios de adequação de grafo Nó Transição Caminho

Critérios de adequação de grafo Nó Teste suíte TS é adequado a nó (i.e., cobre todos os nós) se para cada nó n em G existe t em TS que cobre n (i.e., origem ou destino de t é n) Transição … Caminho …

Critérios de adequação de grafo Nó Teste suíte TS é adequado a nó (i.e., cobre todos os nós) se para cada nó n em G existe t em TS que cobre n (i.e., origem ou destino de t é n) Transição … Caminho … Em geral, número de caminhos de um grafo é infinito

Exercício Reporte suíte de teste adequada a nó Reporte suíte de teste adequada a transição Existe suíte de teste adequada a caminho de até N transições?

Demo EclEmma

Problema Usuário não sabe quão adequada é uma suíte de testes para encontrar erro Duas soluções Cobertura Score de Mutação

Teste de Mutação Verifica se uma suíte de teste é capaz de encontar uma falha no programa modificado com um bug (Fault seeding/injection) Princípio Uma suíte capaz de encontrar vários erros artificiais pode encontrar mais erros reais

Teste de Mutação P T0 T1 T2 … Tn Como saber se TS é adequada para encontrar erros? TS =

Teste de Mutação P’ é uma versão que contém um erro! O que se pode concluir sobre TS? P T0 T1 T2 … Tn P’ T0 T1 T2 … Tn TS =

Teste de Mutação P’ é uma versão que contém um erro! O que se pode concluir sobre TS? P T0 T1 T2 … Tn P’ T0 T1 T2 … Tn TS = Inadequado para encontrar erro introduzido em P’

Teste de Mutação O que o programador deve fazer ao perceber isto? P T0 T1 T2 … Tn P’ T0 T1 T2 … Tn TS =

Teste de Mutação O que o programador deve fazer ao perceber isto? P T0 T1 T2 … Tn P’ T0 T1 T2 … Tn TS = Adicionar novo teste para capturar erro em P’

Teste de Mutação Novo teste deve passar em P e falhar em P’ Definição: TS distingue programas P e P’ P T0 T1 T2 … Tn P’ T0 T1 T2 … Tn TS = Tn+1 

Terminologia Mutante Operador de Mutação Mutante morto Mutante sobrevivente Mutante equivalente

Terminologia Mutante: Programa original modificado Operador de Mutação: Definição de uma transformação (de original para mutante) Mutante morto: Quando a suíte de teste consegue distinguir mutante do original Mutante sobrevivente: Não morto (acima) Mutante equivalente: Semântica do mutante é equivalente ao original

Mutantes sobreviventes Duas razões para P’ sobreviver ao teste de distinção de P em relação a TS Suíte TS não consegue distinguir P e P’ P e P’ são equivalentes => problema indecidível!

Metodologia (Parte 1) Input: P: Pgm, OPS: set of Op Output: set of Pgm Pseudo-code: gerarMutantes /******************************************************* * gera vários novos programas derivados de P. * Para cada um, identifica um operador de * mutação em OPS e uma posicão para aplicá-lo * em P. Em geral, cada mutante inclui apenas * uma modificação. *******************************************************/

Metodologia (Parte 2) Input: P: Pgm, TS: set of Pgm, {P1, P2, …, Pn}: set of Pgm Output: (survivors: set of Pgm, killed: set of Pgm) Pseudo-code: encontreSobreviventes for each Pm in {P1,P2, …,Pn} do // distinguir mutante if (exists some T in TS s.t. RUN(T,Pm) == FAIL) killed = killed U {Pm} else survivors = survivors U {Pm} done return (survivors, killed)

Metodologia (Parte 3) P TS Set of Mutants OPs gerarMutantesencontreSobreviventes sobreviventes novos testes

Score de Mutação Está para o teste de falhas assim como cobertura está para o teste estrutural Score: #mortos / (#mutantes - #equivalentes) Ex. 10 mutantes, 5 mortos, 2 equivalentes. Score = 5/8 = (62.5%)

Limitações Não se sabe se o erro introduzido por um operador de mutação é relevante para encontrar erros reais Identificação de mutantes equivalentes é manual Consome tempo do testador e é passível a erro

Demo MuClipse

Automação da geração de testes

Duas preocupações Entrada (sequência + dados) Classificador Várias técnicas Model-Based Testing (e.g., TARGET), Random Testing (e.g., RANDOOP), Symbolic Testing (e.g., Symstra), Concolic Testing (e.g., DART), etc.

Model-Based Testing (MBT) Modelo orienta o teste de programas Modelo representa comportamento esperado (spec) Testes são gerados a partir do modelo Violação indica que o sistema não está em conformidade com o modelo Principais limitações Incompletude do modelo Dificuldade na construção do modelo

TARGET Entrada são requisitos e parâmetros de geração Documentos Word estruturados descrevem os requisitos Cada arquivo descreve uma feature com vários casos de uso. Um caso de uso possui diversos fluxos (principal, alternativos, e excepcionais). Saída é uma suíte de teste Planilhas no Excel descrevem os casos de teste

Demo TARGET

Random Testing Geração de entradas Seleção de sequência e dados randômica e incremental Principal limitação Degrada com o aumento no tamanho do espaço de estados

Randoop Entrada é um conjunto de classes e parâmetros de configuração Saída é uma suíte de testes Geração do classificador Derivado de conjunto de testes [Pacheco & Ernst, 2005] Específicos da linguagem [Pacheco et al., 2007] Informados pelo usuário

Feedback-directed random test generation. Carlos Pacheco et al., ICSE 2007

Demo RANDOOP

Desafios Melhorar automação Geração de classificadores (oracles) Geração de dados Geração de sequências Melhorar escalabilidade Escalar técnicas além do teste de unidade