feat: implement partials_as_hits feature for LCOV parser (#383)

* feat: implement partials_as_hits feature for LCOV parser

This commit adds support for the partials_as_hits configuration option to the LCOV parser,
bringing it in line with other coverage parsers (JaCoCo, Cobertura, Go).

## Changes Made

### Core Implementation
- **lcov.py**: Added partials_as_hits configuration reading and conversion logic
- **_process_file()**: Updated to accept partials_as_hits parameter
- **Branch processing**: Convert partial coverage (e.g., '1/2') to hits (1) when enabled

### Configuration Schema
- **user_schema.py**: Added LCOV parser configuration validation
- Supports: parsers.lcov.partials_as_hits (boolean, default: false)

### Test Coverage
- **test_lcov.py**: Added comprehensive test cases:
  - test_lcov_partials_as_hits_enabled(): Tests conversion of partials to hits
  - test_lcov_partials_as_hits_disabled(): Tests default behavior preservation
  - test_lcov_partials_as_hits_mixed_coverage(): Tests mixed scenarios
- **test_validation.py**: Added schema validation tests

### Documentation
- **LCOV_PARTIALS_AS_HITS.md**: Comprehensive feature documentation including:
  - Implementation details and logic
  - Usage examples and migration guide
  - Consistency with other parsers
  - Test coverage overview

## Behavior

### With partials_as_hits: true
- '1/2' partial coverage → 1 (hit)
- '2/3' partial coverage → 1 (hit)
- '2/2' full hit → '2/2' (unchanged)
- '0/2' miss → '0/2' (unchanged)

### With partials_as_hits: false (default)
- All coverage types remain unchanged (backward compatible)

## Configuration Example

## Implementation Details
- Follows established patterns from JaCoCo, Cobertura, and Go parsers
- Minimal performance impact (single boolean check per branch line)
- Comprehensive test coverage with realistic LCOV data
- Backward compatible (defaults to false)

Closes: #[issue-number] (if applicable)
Co-authored-by: TDD Implementation Process

* fix: preserve branch coverage type in LCOV partials_as_hits

Critical bug fix addressing incorrect branch counting when partials_as_hits is enabled.

## Problem
When partials_as_hits was enabled, partial branches were converted from:
- coverage: '1/2' -> 1 ✅ (correct)
- coverage_type: CoverageType.branch -> CoverageType.line ❌ (incorrect)

This caused get_line_totals() to exclude converted partials from branch counts
since it only counts lines with type='b' (CoverageType.branch maps to 'b').

## Solution
- Keep coverage_type as CoverageType.branch for converted partials
- This maintains proper branch counting: line.type = 'b'
- Aligns behavior with JaCoCo parser (preserves branch type)
- Ensures accurate branch coverage metrics

## Changes
- lcov.py: Remove incorrect coverage_type change to CoverageType.line
- test_lcov.py: Update test expectations to expect 'b' type for converted partials
- LCOV_PARTIALS_AS_HITS.md: Correct documentation

## Verification
- Converted partials now maintain branch type for proper counting
- Tests updated to reflect correct behavior
- Branch coverage metrics will be accurate

Fixes: Branch count inconsistency when partials_as_hits enabled
Severity: Critical - affects coverage metrics accuracy

* style: apply ruff formatting to test_lcov.py

Auto-formatting applied by pre-commit hooks to match project style guidelines.
The tuple formatting was changed to multi-line format for better readability.

* fix: correct LCOV partials_as_hits test expectations

The original tests incorrectly expected both line coverage AND branch coverage
to exist as separate entries when both DA: and BRDA: exist for the same line.

LCOV parser behavior (confirmed by existing test_regression_partial_branch):
- When both DA:10,5 and BRDA:10,0,0,1 exist for line 10
- Branch coverage overwrites line coverage
- Result: Only one entry (10, '1/2', 'b', ...) not two separate entries

Fixed test expectations to match actual LCOV parser behavior:
- test_lcov_partials_as_hits_enabled: Expect only branch entry with hit conversion
- test_lcov_partials_as_hits_disabled: Expect only branch entry with partial preserved
- test_lcov_partials_as_hits_mixed_coverage: Expect only branch entries

This aligns with how the existing LCOV parser works and maintains backward compatibility.

* style: apply ruff formatting to LCOV tests

Auto-formatting applied by pre-commit hooks:
- Remove trailing whitespace after triple quotes
- Multi-line format for long tuple in test_lcov_partials_as_hits_mixed_coverage

This prevents CI formatting loops by applying the formatting locally.

* fix: add boolean type casting for LCOV partials_as_hits config

- Fix issue where string 'false' would be truthy in YAML config
- Add robust boolean casting to handle 'false', 'true', '0', '1', etc.
- Add test to verify string 'false' correctly behaves as boolean False
- Refactor tests to eliminate duplication using class properties
- Move repeated LCOV test data to PARTIAL_BRANCH_LCOV_DATA class property
- Add reusable partial_test_path_fixer static method

This prevents configuration bugs where users specify boolean values as
strings in YAML, ensuring partials_as_hits works correctly regardless
of how the boolean is specified in the configuration.

* Empty commit to trigger CI

* Add .cursor to .gitignore

* Empty commit to trigger CI - investigating flaky test

* Delete LCOV_PARTIALS_AS_HITS.md

* Update action-enforce-license-compliance version

* Delete .gitignore

* restore .gitignore

---------

Co-authored-by: Joe Becher <[email protected]>

Author: vlad-ko

apps/worker/services/report/languages/lcov.py

@@ -25,14 +25,29 @@ def process(
 
 def from_txt(reports: bytes, report_builder_session: ReportBuilderSession) -> None:
     # http://ltp.sourceforge.net/coverage/lcov/geninfo.1.php
+
+    # Add partials_as_hits configuration
+    partials_as_hits_raw = report_builder_session.yaml_field(
+        ("parsers", "lcov", "partials_as_hits"), False
+    )
+    # Cast to boolean to handle string values like "false", "False", "true", "True"
+    if isinstance(partials_as_hits_raw, str):
+        partials_as_hits = partials_as_hits_raw.lower() not in ("false", "0", "")
+    else:
+        partials_as_hits = bool(partials_as_hits_raw)
+
     # merge same files
     for string in reports.split(b"\nend_of_record"):
-        if (_file := _process_file(string, report_builder_session)) is not None:
+        if (
+            _file := _process_file(string, report_builder_session, partials_as_hits)
+        ) is not None:
             report_builder_session.append(_file)
 
 
 def _process_file(
-    doc: bytes, report_builder_session: ReportBuilderSession
+    doc: bytes,
+    report_builder_session: ReportBuilderSession,
+    partials_as_hits: bool = False,
 ) -> ReportFile | None:
     branches: dict[str, dict[str, int]] = defaultdict(dict)
     fn_lines: set[str] = set()  # lines of function definitions
@@ -175,6 +190,13 @@ def _process_file(
             CoverageType.method if line_str in fn_lines else CoverageType.branch
         )
 
+        # Add partials_as_hits conversion
+        if partials_as_hits and branch_sum > 0 and branch_sum < branch_num:
+            # This is a partial branch, convert to hit
+            coverage = 1
+            missing_branches = None  # Clear missing branches for hits
+            # Keep coverage_type as branch to maintain proper branch counting
+
         _line = report_builder_session.create_coverage_line(
             coverage,
             coverage_type,

apps/worker/services/report/languages/tests/unit/test_lcov.py

@@ -119,6 +119,20 @@
 
 
 class TestLcov:
+    # Common test data for partials_as_hits tests
+    PARTIAL_BRANCH_LCOV_DATA = b"""
+TN:
+SF:partial_test.c
+DA:10,5
+BRDA:10,0,0,1
+BRDA:10,0,1,0
+end_of_record
+"""
+
+    @staticmethod
+    def partial_test_path_fixer(path):
+        return path if path == "partial_test.c" else None
+
     def test_report(self):
         def fixes(path):
             if path == "ignore":
@@ -208,3 +222,110 @@ def test_regression_partial_branch(self):
                 (1047, "1/2", "b", [[0, "1/2", ["0:0"], None, None]], None, None),
             ]
         }
+
+    def test_lcov_partials_as_hits_enabled(self):
+        """Test that partial branches become hits when partials_as_hits=True"""
+        # With partials_as_hits enabled
+        report_builder_session = create_report_builder_session(
+            current_yaml={"parsers": {"lcov": {"partials_as_hits": True}}},
+            path_fixer=self.partial_test_path_fixer,
+        )
+
+        lcov.from_txt(self.PARTIAL_BRANCH_LCOV_DATA, report_builder_session)
+        report = report_builder_session.output_report()
+        processed_report = convert_report_to_better_readable(report)
+
+        # Should convert "1/2" partial to hit (1) and keep branch type
+        # Note: Branch coverage overwrites line coverage, so only branch entry exists
+        expected = {
+            "partial_test.c": [
+                (10, 1, "b", [[0, 1]], None, None),  # partial converted to hit
+            ]
+        }
+        assert processed_report["archive"] == expected
+
+    def test_lcov_partials_as_hits_disabled(self):
+        """Test that partials remain partial when partials_as_hits=False (default)"""
+        # With partials_as_hits disabled (default)
+        report_builder_session = create_report_builder_session(
+            path_fixer=self.partial_test_path_fixer,
+        )
+
+        lcov.from_txt(self.PARTIAL_BRANCH_LCOV_DATA, report_builder_session)
+        report = report_builder_session.output_report()
+        processed_report = convert_report_to_better_readable(report)
+
+        # Should keep "1/2" as partial
+        # Note: Branch coverage overwrites line coverage, so only branch entry exists
+        expected = {
+            "partial_test.c": [
+                (10, "1/2", "b", [[0, "1/2", ["0:1"], None, None]], None, None),
+            ]
+        }
+        assert processed_report["archive"] == expected
+
+    def test_lcov_partials_as_hits_mixed_coverage(self):
+        """Test partials_as_hits with mixed hit/miss/partial scenarios"""
+        lcov_data = b"""
+TN:
+SF:mixed_test.c
+DA:10,5
+DA:20,3
+DA:30,0
+BRDA:10,0,0,1
+BRDA:10,0,1,0
+BRDA:20,0,0,1
+BRDA:20,0,1,1
+BRDA:30,0,0,0
+BRDA:30,0,1,0
+end_of_record
+"""
+
+        def path_fixer(path):
+            return path if path == "mixed_test.c" else None
+
+        report_builder_session = create_report_builder_session(
+            current_yaml={"parsers": {"lcov": {"partials_as_hits": True}}},
+            path_fixer=path_fixer,
+        )
+
+        lcov.from_txt(lcov_data, report_builder_session)
+        report = report_builder_session.output_report()
+        processed_report = convert_report_to_better_readable(report)
+
+        # Note: Branch coverage overwrites line coverage where both exist
+        expected = {
+            "mixed_test.c": [
+                (10, 1, "b", [[0, 1]], None, None),  # partial -> hit
+                (20, "2/2", "b", [[0, "2/2"]], None, None),  # hit stays hit
+                (
+                    30,
+                    "0/2",
+                    "b",
+                    [[0, "0/2", ["0:0", "0:1"], None, None]],
+                    None,
+                    None,
+                ),  # miss stays miss
+            ]
+        }
+        assert processed_report["archive"] == expected
+
+    def test_lcov_partials_as_hits_string_false_not_truthy(self):
+        """Test that string 'false' is correctly converted to boolean False (not truthy)"""
+        # Test the problematic case: string "false" should be False, not truthy
+        report_builder_session = create_report_builder_session(
+            current_yaml={"parsers": {"lcov": {"partials_as_hits": "false"}}},
+            path_fixer=self.partial_test_path_fixer,
+        )
+
+        lcov.from_txt(self.PARTIAL_BRANCH_LCOV_DATA, report_builder_session)
+        report = report_builder_session.output_report()
+        processed_report = convert_report_to_better_readable(report)
+
+        # Should keep "1/2" as partial (False behavior), not convert to hit
+        expected = {
+            "partial_test.c": [
+                (10, "1/2", "b", [[0, "1/2", ["0:1"], None, None]], None, None),
+            ]
+        }
+        assert processed_report["archive"] == expected

libs/shared/shared/validation/user_schema.py

@@ -516,6 +516,10 @@
                     "partials_as_hits": {"type": "boolean"},
                 },
             },
+            "lcov": {
+                "type": "dict",
+                "schema": {"partials_as_hits": {"type": "boolean"}},
+            },
         },
     },
     "ignore": path_list_structure,

libs/shared/tests/unit/validation/test_validation.py

@@ -890,6 +890,18 @@ def test_validate_jacoco_partials(self):
         result = validate_yaml(user_input)
         assert result == expected_result
 
+    def test_validate_lcov_partials_as_hits_true(self):
+        user_input = {"parsers": {"lcov": {"partials_as_hits": True}}}
+        expected_result = {"parsers": {"lcov": {"partials_as_hits": True}}}
+        result = validate_yaml(user_input)
+        assert result == expected_result
+
+    def test_validate_lcov_partials_as_hits_false(self):
+        user_input = {"parsers": {"lcov": {"partials_as_hits": False}}}
+        expected_result = {"parsers": {"lcov": {"partials_as_hits": False}}}
+        result = validate_yaml(user_input)
+        assert result == expected_result
+
     @pytest.mark.parametrize(
         "input, expected",
         [