Structural Software Testing

Structural software testing is a white-box testing technique that evaluates the internal logic, code paths, and architecture of a software system. Unlike black-box testing, it requires knowledge of the source code to design test cases. The goal is to ensure every part of the code is exercised and verified.

• Tests are derived from the internal structure of the code, not external requirements
• Focuses on coverage metrics like statement, branch, and path coverage
• Helps detect dead code, hidden bugs, and unreachable logic early in development

Types of Structural Testing

There are different types of Structural Testing:

1. Control Flow Testing

Control flow testing verifies the sequence in which statements and instructions are executed in a program. It uses a Control Flow Graph (CFG) to map all possible execution paths.

Coverage Criteria

• Statement Coverage: Every statement executed at least once
• Branch Coverage: Every true/false decision tested
• Path Coverage: Every possible path through the code tested
• Condition Coverage: Every boolean sub-expression evaluated

2. Data Flow Testing

Data flow testing tracks the lifecycle of variables — from where they are defined to where they are used or destroyed. It detects anomalies like using undefined variables.

Coverage Criteria

• All-Defs: Every variable definition is reached
• All-Uses: Every use of a variable after definition is tested
• All-DU-Paths: Every definition-to-use path is covered

3. Slice Based Testing

A program slice is a subset of program statements that directly affect the value of a variable at a specific point. Test cases are built around these slices.

Types of Slices

• Static Slice: Based on source code structure alone
• Dynamic Slice: Based on actual execution with specific input
• Backward Slice: Statements that affect a variable's value
• Forward Slice: Statements affected by a variable's value

4. Mutation Testing

Mutation testing introduces small artificial changes (mutations) into the source code to check whether existing test cases can detect them. It measures the quality of test suites.

Common Mutation Operators

• Changing + to - or *
• Flipping > to >= or <
• Replacing AND with OR
• Changing constant values

Structural Testing Process

The Structural Testing Process involves examining the internal structure of the software and designing test cases to ensure that different parts of the code are executed and verified.

• Analyze the Source Code: Review the program's internal logic, control flow, and data flow, and identify statements, branches, conditions, and execution paths to be tested.
• Design Test Cases: Create test cases that cover different code paths, branches, and conditions to achieve the required code coverage.
• Execute Test Cases: Run the designed test cases and observe the program's behavior to verify that the code works as expected.
• Measure Code Coverage: Use code coverage tools to determine how much of the source code has been executed and identify untested areas.
• Identify and Fix Defects: Analyze test results to locate defects, investigate uncovered code segments, and implement necessary fixes.
• Retest and Generate Reports: Re-execute the test cases after fixes are applied and generate coverage reports to verify testing completeness.

Structural Testing Tools

Structural testing tools help analyze the internal structure of software and measure code coverage during testing.

• JaCoCo: Java code coverage tool that measures statement, branch, and line coverage.
• Cobertura: Open-source Java tool used to analyze code coverage and identify untested code.
• GCov: Coverage analysis tool for C/C++ programs used with the GCC compiler.
• BullseyeCoverage: Commercial code coverage tool for measuring test coverage in C and C++ applications.
• Istanbul (nyc): JavaScript code coverage tool that generates detailed coverage reports.
• Coverage.py: Python code coverage tool that measures how much of the code is executed during testing.

Advantages of Structural Testing

• Ensures Thorough Code Coverage: Verifies that different parts of the source code are executed and tested.
• Detects Defects Early: Identifies coding errors, logic flaws, and hidden defects during the development phase.
• Improves Software Quality: Helps ensure the software is reliable, stable, and functions correctly.
• Identifies Dead Code: Detects unused, unreachable, or redundant code that can be removed.
• Supports Test Optimization: Reveals untested areas, helping testers create more effective test cases.
• Facilitates Automation: Many structural testing techniques can be automated using code coverage tools.
• Enhances Code Reliability: Ensures critical code paths and conditions are properly verified.
• Reduces Maintenance Costs: Early defect detection lowers the effort and cost required for fixing issues later in the software lifecycle.

Limitations of Structural Testing

• Requires Programming Knowledge: Testers need a good understanding of the source code and program structure.
• Time-Consuming: Achieving high code coverage can be difficult and time-consuming, especially for large applications.
• Cannot Detect Missing Requirements: It focuses on code implementation and may not identify missing or incorrect requirements.
• Path Explosion Problem: Testing every possible execution path becomes impractical in complex programs.
• Maintenance Effort: Test cases often need updates whenever the code changes.
• May Miss Functional Issues: Even with high code coverage, some functional or user-related defects may remain undetected.

Structural Testing vs Functional Testing