# 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):**

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

**Instrumented Function:**

```python
# 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.
