Example: Code Instrumentation for Coverage Measurement

The objective of coverage measurement is to track whether different branches of a function are hit during execution.

Example Function Before Instrumentation (Python):

def example_function(x):
    if x > 0:
        print("Positive")
    else:
        print("Non-Positive")
    return x * 2

Instrumented Function:

# Initialize coverage tracking global variable
branch_coverage = {
    "example_function_1": False,  # if branch for x > 0
    "example_function_2": False   # else branch
}

def example_function(x):
    if x > 0:
        branch_coverage["example_function_1"] = True
        print("Positive")
    else:
        branch_coverage["example_function_2"] = True
        print("Non-Positive")
    return x * 2

def print_coverage():
    for branch, hit in branch_coverage.items():
        print(f"{branch} was {'hit' if hit else 'not hit'}")

# Example usage
result = example_function(5)
print_coverage()
result = example_function(-3)
print_coverage()

Explanation:

1. Initializing Coverage Tracking: A global dictionary branch_coverage is used to track whether each branch has been hit. Each key in the dictionary represents a unique identifier for a conditional branch in the function.

2. Marking Branches: Before each branch's body, a line is added to set the corresponding entry in branch_coverage to True.

3. Printing Coverage: A helper function print_coverage prints out whether each branch was hit or not.

Why is Coverage Measurement Useful? Tracking code coverage helps in ensuring that all parts (branches) of your code are tested. This ensures:

• Better Quality: Identifies which parts of code are untested, revealing potential bugs or missed logic.

• Reliability: High coverage indicates the application has been tested under many different conditions, making it more reliable.

• Maintenance: Helps developers understand which parts of the codebase are critical and well-tested, making future changes safer.

• Code Insight: Provides insights into code complexity and areas that may need refactoring.

Steps to Implement Instrumentation:

1. Identify Conditional Branches: Determine all places in the function where execution could diverge (e.g., if, else, elif).

2. Assign Unique IDs: Assign a unique key to each branch in the coverage dictionary.

3. Modify Code: Add lines of code before each branch to update the coverage dictionary.

4. Testing: Run the function with different inputs to ensure branches are hit and coverage is recorded.