Luis Master Notes

Search

SearchSearch

Tipos de cobertura

May 03, 2024, 4 min read

Definição: Os tipos de cobertura em testes de software determinam a profundidade com que os testes examinarão o código. Normalmente, eles são aplicados usando gráficos de fluxo de controle (CFGs) para avaliar diferentes aspectos dos caminhos de código do software.

Tipos de cobertura:

  1. Cobertura de nó:

    • Definição: Garante que cada nó (ou bloco básico) no CFG seja executado pelo menos uma vez durante o teste.
    • Meta: Garantir que todas as instruções do programa sejam testadas.

  2. Cobertura de borda:

    • Definição: Garante que cada borda do CFG, que representa um caminho de controle entre dois nós, seja executada pelo menos uma vez.
    • Meta: Confirmar que todas as ramificações no fluxo de controle do programa são testadas, o que normalmente inclui todos os resultados da decisão (verdadeiro e falso).

  3. Loops:

    • Definição: Atenção específica à cobertura dos loops para garantir que os corpos dos loops sejam inseridos zero vezes e várias vezes.
    • Considerações especiais: O teste pode incluir a adição de nós extras para lidar com a inicialização do loop e as condições de término para validar a execução do loop completamente.
    • Objetivo: Verificar o comportamento do software com diferentes iterações de loop, garantindo a robustez no manuseio do loop.

  4. Cobertura de fluxo de dados:

    • Definição: Aumenta a cobertura de nós e bordas ao incluir definições de variáveis (defs) e usos (uses) no CFG.
    • Objetivo: Garantir que todos os valores de variáveis sejam inicializados e usados adequadamente nos caminhos de execução do programa, concentrando-se no ciclo de vida das variáveis dentro do software.
graph TD;
    A(Start) -->|initialize| B[if x > 10];
    B -->|True| C[x = x + 1];
    B -->|False| D[x = x - 1];
    C --> E[End];
    D --> E;
  • Cobertura de nós: Os testes precisam executar os blocos A, B, C, D e E.
  • Cobertura de borda: Os testes precisam cobrir as transições A-B, B-C, B-D, C-E e D-E.

Relevância:

  • Essas métricas de cobertura são cruciais para avaliar a eficácia dos casos de teste na exploração de diferentes cenários na execução do programa. Elas ajudam a identificar partes não testadas do código, garantindo testes abrangentes que levam a uma maior qualidade do software.

Esta nota atômica fornece uma compreensão clara dos diferentes tipos de cobertura em testes de software, destacando suas definições, objetivos e importância para garantir um produto de software bem testado.

Atomic Note: Types of Coverage in Software Testing

Definition: Coverage types in software testing determine how thoroughly the tests will examine the code. They are typically applied using Control Flow Graphs (CFGs) to assess different aspects of the software’s code paths.

Types of Coverage:

  1. Node Coverage:

    • Definition: Ensures that every node (or basic block) in the CFG is executed at least once during testing.
    • Goal: To guarantee that every statement in the program is tested.

  2. Edge Coverage:

    • Definition: Ensures that every edge in the CFG, which represents a control path between two nodes, is executed at least once.
    • Goal: To confirm that all branches in the program control flow are tested, which typically includes all decision outcomes (true and false).

  3. Loops:

    • Definition: Specific attention to the coverage of loops to ensure that loop bodies are entered both zero times and multiple times.
    • Special Considerations: Testing might include adding extra nodes to handle loop initialization and termination conditions to validate the loop execution thoroughly.
    • Goal: To check the behavior of the software with different loop iterations, ensuring robustness in loop handling.

  4. Data Flow Coverage:

    • Definition: Augments node and edge coverage by including variable definitions (defs) and uses (uses) in the CFG.
    • Goal: To ensure that all variable values are appropriately initialized and used across the program’s execution paths, focusing on the lifecycle of variables within the software.

Example of Node and Edge Coverage with MermaidJS:

graph TD;
    A(Start) -->|initialize| B[if x > 10];
    B -->|True| C[x = x + 1];
    B -->|False| D[x = x - 1];
    C --> E[End];
    D --> E;
  • Node Coverage: Tests need to execute blocks A, B, C, D, and E.
  • Edge Coverage: Tests need to cover transitions A-B, B-C, B-D, C-E, and D-E.

Relevance:

  • These coverage metrics are crucial for assessing the effectiveness of test cases in exploring different scenarios in the program’s execution. They help in identifying untested parts of the code, ensuring comprehensive testing that leads to higher software quality.

This atomic note provides a clear understanding of the different types of coverage in software testing, highlighting their definitions, goals, and importance in ensuring a well-tested software product.

Graph View

Backlinks