Data Flow Testing

Vários critérios de adequação até aqui Baseado em entradas de função (funcional)‏ Baseado na estrutura do programa (estrutural)‏ Baseado em faltas injetadas (mutação)‏

Algumas limitações também... Funcional  Inadequado para construir entradas que leva a caminhos específicos do programa Estrutural  Pode gerar muitos caminhos desnecessários (e.g., exercitar mesmo loop repetidamente.)‏ Baseado em falhas  Modelo de falhas possivelmente irrealista, alto custo de execução de mutantes, alto custo de identificação de programas equivalentes

Critério baseado em fluxo de dados Recordar origem de um bug:  Falta modifica estado de um programa incorretamente  Falha manifesta-se através da leitura deste estado Observação Relação de leitura e escrita entre dados é importante!

Critério baseado em fluxo de dados Abordagem  Suíte deve incluir testes que executam statements logicamente relacionados E.g., escrita e posterior leitura de um campo de um objeto devem aparecer em um mesmo teste

DU Pair Associação de definição e uso de variáveis do programa  Neste contexto, uma definição é uma nova atribuição de valor a uma variável

Exemplo 01: public static int foo(int a) { 02: if (a > 10) { 03: a++; 04: } 05:... 06: return a; 07: } DU pairs: (01,02), (01,03),... Assuma que parâmetro define um valor

Exemplo 01: public static int foo(int a) { 02: if (a > 10) { 03: a++; 04: } 05:...// nova definição de a? 06: return a; 07: } DU pairs: (01,02), (01,03), (03,06)? Linha 05 pode redefinir variável a.

DU Path Caminho que associa uma definição ao uso de uma variável Vários DU Paths para um DU Pair  E.g. 01: int x = 1; 02: if (...) { 03:... 04: } else { 05:... 07: } 08: System.out.println(“x value”+ x);

Cobertura de uma suíte de testes du pairs: fração de todos os pares du que são cobertos por pelo menos um teste du paths: fração de todos os caminhos (desconsiderando loop) du que são cobertos por pelo menos um teste definitions: fração de definições cobertas por pelo menos um teste

Desafios gerais de análises estáticas Abrangência: whole-program analysis, main Profundidade: intraprocedural, interprocedural Características de programas: encapsulamento de dados, ponteiros e arrays

Interprocedural public class Sample { int x; public static void main(String[] args){ Sample s = new Sample(); s.x = read(System.in); if (s.x > 10) { s.x--; } s.f(); } public void f() { s.x++; } } Definição de s.x se propaga até Sample.f

Interprocedural public class Sample { int x; public static void main(String[] args){ Sample s = new Sample(); s.x = read(System.in); if (s.x > 10) { s.x--; } s.f(); } public void f() { s.x++; } } Definição de s.x se propaga até Sample.f Duas definições alcançam a entrada de f

Interprocedural public class Sample { int x; public static void main(String[] args){ Sample s = new Sample(); s.x = read(System.in); if (s.x > 10) { s.x--; } s.f(); } public void f() { s.x++; } } Definição de s.x se propaga até Sample.f Duas definições alcançam a entrada de f Análise é feita sobre funções alcançáveis a partir de main

Análise a partir de função main Reduz complexidade da análise estática  Muitas funções não são alcançáveis (usadas)‏ No contexto de testes é útil para medir cobertura  Requisitos de teste (cobertura) são construídos a partir de uma sequência de teste Mas desconsidera vários comportamentos

Análise a partir de função main Reduz complexidade da análise estática  Muitas funções não são alcançáveis (usadas)‏ No contexto de testes é útil para medir cobertura  Requisitos de teste (cobertura) são construídos a partir de uma sequência de teste Mas desconsidera vários comportamentos Nota: as vezes, não há uma função main a analisar

Alternativa: construção de contextos Mas que contextos são esses? (além de main)‏  Heurística para OO: assuma que métodos de uma classe estão relacionados

Várias funções e encapsulamento public class Stack { int num; T[] elems; public void push(T t) { num++; elems[num]=t; } public T pop() { elems[num] = null; num--; } public T peek() { return elem[num]; } }

Várias funções e encapsulamento public class Stack { int num; T[] elems; public void push(T t) { num = num + 1; elems[num]=t; } public T pop() { elems[num] = null; num = num - 1; } public T peek() { return elem[num]; } } definições e uso

Note que não há função main associando peek, push, e pop.

Encapsulamento de dados public class Foo { Stack s; public Stack getStack() { return s; } public void foo() {...getStack().peek();...} public void bar(int k) {...getStack().push(k);...} } public class Stack { int num; T[] elems; public void push(T t) { num++;... } public T pop() {... ; num--; } public T peek() { return elem[num]; } } Foo.foo usa definições construídas em Foo.bar.

Encapsulamento de dados public class Stack { int num; T[] elems; public void push(T t) { num++;... } public T pop() {... ; num--; } public T peek() { return elem[num]; } } Campo do tipo Stack é estado encapsulado em Foo. Foo.foo usa definições construídas em Foo.bar. public class Foo { Stack s; public Stack getStack() { return s; } public void foo() {...getStack().peek();...} public void bar(int k) {...getStack().push(k);...} }

Encapsulamento de dados public class Foo { Stack s; public Stack getStack() { return s; } public void foo() {...getStack().peek();...} public void bar(int k) {...getStack().push(k);...} } public class Foo2 { Stack s2; public Stack getStack2() { return s2; } public void foo2() {...getStack().peek();...} public void bar2(int k) {...getStack().push(k);...} } Note, porém, que bar e foo2 (ou bar2 e foo ) não estão associados!

Leituras adicionais Capítulo 13 (Data Flow Testing) do livro “Software Testing and Analysis” “Efficient Computation of Interprocedural Definition-Use Chains”, M. J. Harrold and M. L. Soffa, ACM TOPLAS 1994 Nota: análise que consideram encapsulamento ainda são poucas!