Enhance Lcov format parse functionaility (#493)

* Enhance LCov report parsing to include branch coverage and function hit filtering

* Add unit tests for the changes made to the Lcov parsing function.

* Update diff_cover/violationsreporters/violations_reporter.py

Co-authored-by: Javier Buzzi <[email protected]>

* Fixed comments

* Reformatted the codes

* Enhance LCOV coverage reporting by adding support for function coverage and improving branch coverage logic. Introduce new tests for real-world C++, Python, and TypeScript LCOV data, ensuring accurate output and handling of various coverage formats.

* Refactor LCOV coverage logic in violations_reporter.py to improve clarity and maintainability. Update test cases in test_violations_reporter.py to cover new scenarios for branch and function coverage overrides.

* Refactor test cases in TestDiffCoverIntegration to compare console output against expected results for LCOV data. Add new fixture files for C++ and TypeScript console reports to ensure accurate validation of coverage output.

---------

Co-authored-by: Jacob Tan <[email protected]>
Co-authored-by: Javier Buzzi <[email protected]>

Author: 3 people

diff_cover/violationsreporters/violations_reporter.py

@@ -308,8 +308,15 @@ def __init__(self, lcov_roots, src_roots=None):
     def parse(lcov_file):
         """
         Parse a single LCov coverage report
-        File format: https://ltp.sourceforge.net/coverage/lcov/geninfo.1.php
+        File format: https://linux.die.net/man/1/geninfo
+        More info: https://github.com/linux-test-project/lcov/issues/113#issuecomment-762335134
         """
+        branch_coverage = defaultdict(
+            lambda: defaultdict(lambda: {"total": 0, "hit": 0, "executions": 0})
+        )
+        function_lines = defaultdict(
+            dict
+        )  # { source_file: { func_name: (line_no, hit_count) } }
         lcov_report = defaultdict(dict)
         lcov = open(lcov_file)
         while True:
@@ -336,22 +343,92 @@ def parse(lcov_file):
                 if line_no not in lcov_report[source_file]:
                     lcov_report[source_file][line_no] = 0
                 lcov_report[source_file][line_no] += num_executions
+            elif directive == "BRDA":
+                args = content.split(",")
+                if len(args) != 4:
+                    raise ValueError(f"Unknown syntax in lcov report: {line}")
+                if source_file is None:
+                    raise ValueError(
+                        f"No source file specified for line coverage: {line}"
+                    )
+                line_no = int(args[0])
+                taken = (
+                    int(args[3]) if args[3] != "-" else 0
+                )  # Handle '-' for untaken branches
+                branch_coverage[source_file][line_no]["total"] += 1
+                branch_coverage[source_file][line_no]["executions"] += taken
+                if taken > 0:
+                    branch_coverage[source_file][line_no]["hit"] += 1
+            elif directive == "FN":
+                args = content.split(",")
+                if len(args) != 2:
+                    raise ValueError(f"Unknown syntax in lcov report: {line}")
+                if source_file is None:
+                    raise ValueError(
+                        f"No source file specified for line coverage: {line}"
+                    )
+                line_no = int(args[0])
+                func_name = args[1]
+                function_lines[source_file][func_name] = (line_no, 0)
+            elif directive == "FNDA":
+                args = content.split(",")
+                if len(args) != 2:
+                    raise ValueError(f"Unknown syntax in lcov report: {line}")
+                if source_file is None:
+                    raise ValueError(
+                        f"No source file specified for line coverage: {line}"
+                    )
+                hit_count = int(args[0])
+                func_name = args[1]
+                if func_name in function_lines[source_file]:
+                    line_no, _ = function_lines[source_file][func_name]
+                    function_lines[source_file][func_name] = (line_no, hit_count)
             elif directive in [
-                "TN",
-                "FNF",
-                "FNH",
-                "FN",
-                "FNDA",
-                "LH",
-                "LF",
-                "BRF",
-                "BRH",
-                "BRDA",
-                "VER",
+                "TN",  # Test name
+                "FNF",  # Functions found
+                "FNH",  # Functions hit
+                "LH",  # Lines hit
+                "LF",  # Lines found
+                "BRF",  # Branches found
+                "BRH",  # Branches hit
+                "VER",  # Version
+                "FNL",  # Function line coverage (alternative format)
+                "FNA",  # Function name (alternative format)
             ]:
-                # these are valid lines, but not we don't need them
+                # Valid directives that we don't need to process
                 continue
             elif directive == "end_of_record":
+                # Process collected coverage data for current source file
+
+                # 1. Apply branch coverage logic
+                for line_no, info in branch_coverage[source_file].items():
+                    has_da_directive = line_no in lcov_report[source_file]
+
+                    if not has_da_directive:
+                        # No line execution data, use branch coverage
+                        if info["total"] > 0 and info["hit"] < info["total"]:
+                            lcov_report[source_file][
+                                line_no
+                            ] = 0  # Partial branch coverage
+                        else:
+                            lcov_report[source_file][line_no] = info["executions"]
+                        continue
+                    if not lcov_report[source_file][line_no]:
+                        # Line shows 0 executions, but check if branches were hit
+                        if info["executions"] > 0:
+                            lcov_report[source_file][line_no] = info["executions"]
+                    # Note: Don't override existing positive execution counts
+
+                # 2. Apply function coverage logic
+                for func_name, (line_no, hit) in function_lines[source_file].items():
+                    if line_no not in lcov_report[source_file]:
+                        # No existing line data, use function hit count
+                        lcov_report[source_file][line_no] = hit
+                    # Note: Don't override existing line execution data
+
+                # 3. Clean up temporary data for current file
+                branch_coverage[source_file].clear()
+                function_lines[source_file].clear()
                 source_file = None
             else:
                 raise ValueError(f"Unknown syntax in lcov report: {line}")

tests/fixtures/cpp_functions_console_report.txt

@@ -0,0 +1,10 @@
+-------------
+Diff Coverage
+Diff: origin/main...HEAD, staged and unstaged changes
+-------------
+calculator.cpp (92.3%): Missing lines 12
+-------------
+Total:   13 lines
+Missing: 1 line
+Coverage: 92%
+------------- 

tests/fixtures/cpp_functions_coverage.lcov

@@ -0,0 +1,30 @@
+TN:
+SF:calculator.cpp
+FNL:0,3,4
+FNA:0,1,_ZN10Calculator3addEdd
+FNL:1,7,12
+FNA:1,2,_ZN10Calculator6divideEdd
+FNL:2,14,28
+FNA:2,2,_ZN10Calculator14processNumbersE
+FNF:3
+FNH:3
+DA:3,1
+DA:4,1
+DA:7,2
+DA:8,2
+DA:9,1
+DA:11,1
+DA:12,0
+DA:14,2
+DA:16,2
+DA:17,4
+DA:18,1
+DA:20,2
+DA:21,2
+DA:23,8
+DA:24,6
+DA:27,2
+DA:28,2
+LF:17
+LH:16
+end_of_record 

tests/fixtures/git_diff_cpp.txt

@@ -0,0 +1,50 @@
+diff --git a/calculator.cpp b/calculator.cpp
+new file mode 100644
+index 0000000..1234567
+--- /dev/null
++++ b/calculator.cpp
+@@ -0,0 +1,44 @@
++#include "calculator.h"
++
++double Calculator::add(double a, double b) {
++    return a + b;
++}
++
++double Calculator::divide(double a, double b) {
++    if (b == 0) {
++        throw std::invalid_argument("Division by zero");
++    }
++    return a / b;
++}
++
++std::vector<double> Calculator::processNumbers(const std::vector<double>& numbers,
++                                             std::function<double(double)> processor) {
++    if (!processor) {
++        processor = [](double x) { return x * 2; };
++    }
++
++    std::vector<double> result;
++    result.reserve(numbers.size());
++    
++    for (const auto& num : numbers) {
++        result.push_back(processor(num));
++    }
++    
++    return result;
++}
++
++std::string Calculator::getGrade(double score) {
++    if (score < 0 || score > 100) {
++        throw std::invalid_argument("Invalid score");
++    }
++    
++    if (score >= 90) {
++        return "A";
++    } else if (score >= 80) {
++        return "B";
++    } else if (score >= 70) {
++        return "C";
++    } else {
++        return "F";
++    }
++} 

tests/fixtures/git_diff_cpp_functions.txt

@@ -0,0 +1,28 @@
+diff --git a/calculator.cpp b/calculator.cpp
+new file mode 100644
+index 0000000..abc1234
+--- /dev/null
++++ b/calculator.cpp
+@@ -0,0 +1,28 @@
++#include "calculator.h"
++
++double Calculator::add(double a, double b) {
++    return a + b;
++}
++
++double Calculator::divide(double a, double b) {
++    if (b == 0) {
++        throw std::invalid_argument("Division by zero");
++    }
++    return a / b;
++}
++
++std::vector<double> Calculator::processNumbers(const std::vector<double>& numbers, std::function<double(double)> processor) {
++    std::vector<double> result;
++    
++    for (const auto& num : numbers) {
++        result.push_back(processor(num));
++    }
++    
++    return result;
++} 

tests/fixtures/git_diff_python.txt

@@ -0,0 +1,38 @@
+diff --git a/calculator.py b/calculator.py
+new file mode 100644
+index 0000000..abcdef1
+--- /dev/null
++++ b/calculator.py
+@@ -0,0 +1,32 @@
++from typing import List, Callable
++
++class Calculator:
++    def add(self, a: float, b: float) -> float:
++        """Function coverage example"""
++        return a + b
++
++    def divide(self, a: float, b: float) -> float:
++        """Branch coverage example"""
++        if b == 0:
++            raise ValueError("Division by zero")
++        return a / b
++
++    def process_numbers(self, numbers: List[float], processor: Callable[[float], float] = None) -> List[float]:
++        """Lambda function coverage example"""
++        if processor is None:
++            processor = lambda x: x * 2
++        return list(map(processor, numbers))
++
++    def get_grade(self, score: float) -> str:
++        """Line and branch coverage example"""
++        if score < 0 or score > 100:
++            raise ValueError("Invalid score")
++        
++        if score >= 90:
++            return "A"
++        elif score >= 80:
++            return "B"
++        elif score >= 70:
++            return "C"
++        else:
++            return "F" 

tests/fixtures/git_diff_typescript.txt

@@ -0,0 +1,45 @@
+diff --git a/src/calculator.ts b/src/calculator.ts
+new file mode 100644
+index 0000000..fedcba0
+--- /dev/null
++++ b/src/calculator.ts
+@@ -0,0 +1,40 @@
++export class Calculator {
++  // Function coverage
++  add(a: number, b: number): number {
++    return a + b;
++  }
++
++  // Branch coverage
++  divide(a: number, b: number): number {
++    if (b === 0) {
++      throw new Error("Division by zero");
++    }
++    return a / b;
++  }
++
++  // Anonymous function coverage
++  processNumbers(
++    numbers: number[],
++    processor: (n: number) => number = (n) => n * 2
++  ): number[] {
++    return numbers.map(processor);
++  }
++
++  // Line and branch coverage
++  getGrade(score: number): string {
++    if (score < 0 || score > 100) {
++      throw new Error("Invalid score");
++    }
++
++    if (score >= 90) {
++      return "A";
++    } else if (score >= 80) {
++      return "B";
++    } else if (score >= 70) {
++      return "C";
++    } else {
++      return "F";
++    }
++  }
++} 

tests/fixtures/git_diff_typescript_branches.txt

@@ -0,0 +1,29 @@
+diff --git a/src/calculator.ts b/src/calculator.ts
+new file mode 100644
+index 0000000..def5678
+--- /dev/null
++++ b/src/calculator.ts
+@@ -0,0 +1,36 @@
++export class Calculator {
++  
++  static divide(a: number, b: number): number {
++    if (b === 0) {
++      throw new Error('Division by zero');
++    }
++    return a / b;
++  }
++  
++  static getGrade(score: number): string {
++    if (score >= 90) {
++      return 'A';
++    } else if (score >= 80) {
++      return 'B';
++    } else if (score >= 70) {
++      return 'C';
++    } else if (score >= 60) {
++      return 'D';
++    } else {
++      return 'F';
++    }
++  }
++} 

tests/fixtures/lcov.info

@@ -21,4 +21,4 @@ LH:6
 BRF:0
 BRH:0
 BRDA:3,0,0,0
-end_of_record
+end_of_record

tests/fixtures/real_cpp_console_report.txt

@@ -0,0 +1,10 @@
+-------------
+Diff Coverage
+Diff: origin/main...HEAD, staged and unstaged changes
+-------------
+calculator.cpp (96.4%): Missing lines 12
+-------------
+Total:   28 lines
+Missing: 1 line
+Coverage: 96%
+-------------