feat: add JaCoCo test coverage support for Java optimization

- Add JaCoCo Maven plugin management to build_tools.py:
  - is_jacoco_configured() to check if plugin exists
  - add_jacoco_plugin_to_pom() to inject plugin configuration
  - get_jacoco_xml_path() for coverage report location

- Add JacocoCoverageUtils class to coverage_utils.py:
  - Parses JaCoCo XML reports into CoverageData objects
  - Handles method boundary detection and line/branch coverage

- Update test_runner.py to support coverage collection:
  - run_behavioral_tests() now handles enable_coverage=True
  - Automatically adds JaCoCo plugin and runs jacoco:report goal

- Update critic.py to enforce 60% coverage threshold for Java
  (previously Java was bypassed)

- Add comprehensive test suite with 19 tests for coverage functionality

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: misrasaurabh1

codeflash/languages/java/build_tools.py

@@ -14,10 +14,6 @@
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    pass
 
 logger = logging.getLogger(__name__)
 
@@ -198,23 +194,23 @@ def _extract_java_version_from_pom(root: ET.Element, ns: dict[str, str]) -> str
     """
     # Check properties
     for prop_name in ("maven.compiler.source", "java.version", "maven.compiler.release"):
-        for props in [root.find(f"m:properties", ns), root.find("properties")]:
+        for props in [root.find("m:properties", ns), root.find("properties")]:
             if props is not None:
                 for prop in [props.find(f"m:{prop_name}", ns), props.find(prop_name)]:
                     if prop is not None and prop.text:
                         return prop.text
 
     # Check compiler plugin configuration
-    for build in [root.find(f"m:build", ns), root.find("build")]:
+    for build in [root.find("m:build", ns), root.find("build")]:
         if build is not None:
-            for plugins in [build.find(f"m:plugins", ns), build.find("plugins")]:
+            for plugins in [build.find("m:plugins", ns), build.find("plugins")]:
                 if plugins is not None:
-                    for plugin in plugins.findall(f"m:plugin", ns) + plugins.findall("plugin"):
-                        artifact_id = plugin.find(f"m:artifactId", ns) or plugin.find("artifactId")
+                    for plugin in plugins.findall("m:plugin", ns) + plugins.findall("plugin"):
+                        artifact_id = plugin.find("m:artifactId", ns) or plugin.find("artifactId")
                         if artifact_id is not None and artifact_id.text == "maven-compiler-plugin":
-                            config = plugin.find(f"m:configuration", ns) or plugin.find("configuration")
+                            config = plugin.find("m:configuration", ns) or plugin.find("configuration")
                             if config is not None:
-                                source = config.find(f"m:source", ns) or config.find("source")
+                                source = config.find("m:source", ns) or config.find("source")
                                 if source is not None and source.text:
                                     return source.text
 
@@ -554,9 +550,8 @@ def install_codeflash_runtime(project_root: Path, runtime_jar_path: Path) -> boo
         if result.returncode == 0:
             logger.info("Successfully installed codeflash-runtime to local Maven repository")
             return True
-        else:
-            logger.error("Failed to install codeflash-runtime: %s", result.stderr)
-            return False
+        logger.error("Failed to install codeflash-runtime: %s", result.stderr)
+        return False
 
     except Exception as e:
         logger.exception("Failed to install codeflash-runtime: %s", e)
@@ -633,6 +628,160 @@ def add_codeflash_dependency_to_pom(pom_path: Path) -> bool:
         return False
 
 
+JACOCO_PLUGIN_VERSION = "0.8.11"
+
+
+def is_jacoco_configured(pom_path: Path) -> bool:
+    """Check if JaCoCo plugin is already configured in pom.xml.
+
+    Args:
+        pom_path: Path to the pom.xml file.
+
+    Returns:
+        True if JaCoCo plugin is configured, False otherwise.
+
+    """
+    if not pom_path.exists():
+        return False
+
+    try:
+        tree = ET.parse(pom_path)
+        root = tree.getroot()
+
+        # Handle Maven namespace
+        ns = {"m": "http://maven.apache.org/POM/4.0.0"}
+        ns_prefix = "{http://maven.apache.org/POM/4.0.0}"
+
+        # Check if namespace is used
+        use_ns = root.tag.startswith("{")
+        if not use_ns:
+            ns_prefix = ""
+
+        # Find build/plugins section
+        build = root.find(f"{ns_prefix}build" if use_ns else "build")
+        if build is None:
+            return False
+
+        plugins = build.find(f"{ns_prefix}plugins" if use_ns else "plugins")
+        if plugins is None:
+            return False
+
+        # Check for JaCoCo plugin
+        for plugin in plugins.findall(f"{ns_prefix}plugin" if use_ns else "plugin"):
+            group_id = plugin.find(f"{ns_prefix}groupId" if use_ns else "groupId")
+            artifact_id = plugin.find(f"{ns_prefix}artifactId" if use_ns else "artifactId")
+            if artifact_id is not None and artifact_id.text == "jacoco-maven-plugin":
+                # Verify groupId if present (it's optional for org.jacoco)
+                if group_id is None or group_id.text == "org.jacoco":
+                    return True
+
+        return False
+
+    except ET.ParseError as e:
+        logger.warning("Failed to parse pom.xml for JaCoCo check: %s", e)
+        return False
+
+
+def add_jacoco_plugin_to_pom(pom_path: Path) -> bool:
+    """Add JaCoCo Maven plugin to pom.xml for coverage collection.
+
+    Args:
+        pom_path: Path to the pom.xml file.
+
+    Returns:
+        True if plugin was added or already present, False on error.
+
+    """
+    if not pom_path.exists():
+        logger.error("pom.xml not found: %s", pom_path)
+        return False
+
+    # Check if already configured
+    if is_jacoco_configured(pom_path):
+        logger.info("JaCoCo plugin already configured in pom.xml")
+        return True
+
+    try:
+        tree = ET.parse(pom_path)
+        root = tree.getroot()
+
+        # Handle Maven namespace
+        ns_prefix = "{http://maven.apache.org/POM/4.0.0}"
+
+        # Check if namespace is used
+        use_ns = root.tag.startswith("{")
+        if not use_ns:
+            ns_prefix = ""
+
+        # Find or create build section
+        build = root.find(f"{ns_prefix}build" if use_ns else "build")
+        if build is None:
+            build = ET.SubElement(root, f"{ns_prefix}build" if use_ns else "build")
+
+        # Find or create plugins section
+        plugins = build.find(f"{ns_prefix}plugins" if use_ns else "plugins")
+        if plugins is None:
+            plugins = ET.SubElement(build, f"{ns_prefix}plugins" if use_ns else "plugins")
+
+        # Create JaCoCo plugin element
+        plugin = ET.SubElement(plugins, f"{ns_prefix}plugin" if use_ns else "plugin")
+
+        group_id = ET.SubElement(plugin, f"{ns_prefix}groupId" if use_ns else "groupId")
+        group_id.text = "org.jacoco"
+
+        artifact_id = ET.SubElement(plugin, f"{ns_prefix}artifactId" if use_ns else "artifactId")
+        artifact_id.text = "jacoco-maven-plugin"
+
+        version = ET.SubElement(plugin, f"{ns_prefix}version" if use_ns else "version")
+        version.text = JACOCO_PLUGIN_VERSION
+
+        # Create executions section
+        executions = ET.SubElement(plugin, f"{ns_prefix}executions" if use_ns else "executions")
+
+        # Add prepare-agent execution
+        exec1 = ET.SubElement(executions, f"{ns_prefix}execution" if use_ns else "execution")
+        exec1_id = ET.SubElement(exec1, f"{ns_prefix}id" if use_ns else "id")
+        exec1_id.text = "prepare-agent"
+        exec1_goals = ET.SubElement(exec1, f"{ns_prefix}goals" if use_ns else "goals")
+        exec1_goal = ET.SubElement(exec1_goals, f"{ns_prefix}goal" if use_ns else "goal")
+        exec1_goal.text = "prepare-agent"
+
+        # Add report execution
+        exec2 = ET.SubElement(executions, f"{ns_prefix}execution" if use_ns else "execution")
+        exec2_id = ET.SubElement(exec2, f"{ns_prefix}id" if use_ns else "id")
+        exec2_id.text = "report"
+        exec2_phase = ET.SubElement(exec2, f"{ns_prefix}phase" if use_ns else "phase")
+        exec2_phase.text = "test"
+        exec2_goals = ET.SubElement(exec2, f"{ns_prefix}goals" if use_ns else "goals")
+        exec2_goal = ET.SubElement(exec2_goals, f"{ns_prefix}goal" if use_ns else "goal")
+        exec2_goal.text = "report"
+
+        # Write back to file
+        tree.write(pom_path, xml_declaration=True, encoding="utf-8")
+        logger.info("Added JaCoCo plugin to pom.xml")
+        return True
+
+    except ET.ParseError as e:
+        logger.error("Failed to parse pom.xml: %s", e)
+        return False
+    except Exception as e:
+        logger.exception("Failed to add JaCoCo plugin to pom.xml: %s", e)
+        return False
+
+
+def get_jacoco_xml_path(project_root: Path) -> Path:
+    """Get the expected path to the JaCoCo XML report.
+
+    Args:
+        project_root: Root directory of the Maven project.
+
+    Returns:
+        Path to the JaCoCo XML report file.
+
+    """
+    return project_root / "target" / "site" / "jacoco" / "jacoco.xml"
+
+
 def find_test_root(project_root: Path) -> Path | None:
     """Find the test root directory for a Java project.
 

codeflash/languages/java/test_runner.py

@@ -15,18 +15,17 @@
 import xml.etree.ElementTree as ET
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from codeflash.code_utils.code_utils import get_run_tmp_file
 from codeflash.languages.base import TestResult
 from codeflash.languages.java.build_tools import (
+    add_jacoco_plugin_to_pom,
     find_maven_executable,
-    find_test_root,
+    get_jacoco_xml_path,
+    is_jacoco_configured,
 )
 
-if TYPE_CHECKING:
-    pass
-
 logger = logging.getLogger(__name__)
 
 
@@ -72,7 +71,7 @@ def run_behavioral_tests(
         candidate_index: Index of the candidate being tested.
 
     Returns:
-        Tuple of (result_xml_path, subprocess_result, sqlite_db_path, None).
+        Tuple of (result_xml_path, subprocess_result, sqlite_db_path, coverage_xml_path).
 
     """
     project_root = project_root or cwd
@@ -88,21 +87,32 @@ def run_behavioral_tests(
     run_env["CODEFLASH_TEST_ITERATION"] = str(candidate_index)
     run_env["CODEFLASH_OUTPUT_FILE"] = str(sqlite_db_path)  # SQLite output path
 
+    # If coverage is enabled, ensure JaCoCo is configured
+    coverage_xml_path: Path | None = None
+    if enable_coverage:
+        pom_path = project_root / "pom.xml"
+        if pom_path.exists():
+            if not is_jacoco_configured(pom_path):
+                logger.info("Adding JaCoCo plugin to pom.xml for coverage collection")
+                add_jacoco_plugin_to_pom(pom_path)
+            coverage_xml_path = get_jacoco_xml_path(project_root)
+
     # Run Maven tests
     result = _run_maven_tests(
         project_root,
         test_paths,
         run_env,
         timeout=timeout or 300,
         mode="behavior",
+        enable_coverage=enable_coverage,
     )
 
     # Find or create the JUnit XML results file
     surefire_dir = project_root / "target" / "surefire-reports"
     result_xml_path = _get_combined_junit_xml(surefire_dir, candidate_index)
 
-    # Return sqlite_db_path as the third element (was None before)
-    return result_xml_path, result, sqlite_db_path, None
+    # Return coverage_xml_path as the fourth element when coverage is enabled
+    return result_xml_path, result, sqlite_db_path, coverage_xml_path
 
 
 def run_benchmarking_tests(
@@ -254,10 +264,10 @@ def _get_combined_junit_xml(surefire_dir: Path, candidate_index: int) -> Path:
 
 def _write_empty_junit_xml(path: Path) -> None:
     """Write an empty JUnit XML results file."""
-    xml_content = '''<?xml version="1.0" encoding="UTF-8"?>
+    xml_content = """<?xml version="1.0" encoding="UTF-8"?>
 <testsuite name="NoTests" tests="0" failures="0" errors="0" skipped="0" time="0">
 </testsuite>
-'''
+"""
     path.write_text(xml_content, encoding="utf-8")
 
 
@@ -317,6 +327,7 @@ def _run_maven_tests(
     env: dict[str, str],
     timeout: int = 300,
     mode: str = "behavior",
+    enable_coverage: bool = False,
 ) -> subprocess.CompletedProcess:
     """Run Maven tests with Surefire.
 
@@ -326,6 +337,7 @@ def _run_maven_tests(
         env: Environment variables.
         timeout: Maximum execution time in seconds.
         mode: Testing mode - "behavior" or "performance".
+        enable_coverage: Whether to enable JaCoCo coverage collection.
 
     Returns:
         CompletedProcess with test results.
@@ -345,7 +357,11 @@ def _run_maven_tests(
     test_filter = _build_test_filter(test_paths, mode=mode)
 
     # Build Maven command
-    cmd = [mvn, "test", "-fae"]  # Fail at end to run all tests
+    # When coverage is enabled, run both test and jacoco:report goals
+    if enable_coverage:
+        cmd = [mvn, "test", "jacoco:report", "-fae"]  # Fail at end to run all tests
+    else:
+        cmd = [mvn, "test", "-fae"]  # Fail at end to run all tests
 
     if test_filter:
         cmd.append(f"-Dtest={test_filter}")
@@ -419,12 +435,11 @@ def _build_test_filter(test_paths: Any, mode: str = "behavior") -> str:
                     class_name = _path_to_class_name(test_file.benchmarking_file_path)
                     if class_name:
                         filters.append(class_name)
-            else:
-                # For behavior mode, use instrumented_behavior_file_path
-                if hasattr(test_file, "instrumented_behavior_file_path") and test_file.instrumented_behavior_file_path:
-                    class_name = _path_to_class_name(test_file.instrumented_behavior_file_path)
-                    if class_name:
-                        filters.append(class_name)
+            # For behavior mode, use instrumented_behavior_file_path
+            elif hasattr(test_file, "instrumented_behavior_file_path") and test_file.instrumented_behavior_file_path:
+                class_name = _path_to_class_name(test_file.instrumented_behavior_file_path)
+                if class_name:
+                    filters.append(class_name)
         return ",".join(filters) if filters else ""
 
     return ""

codeflash/result/critic.py

@@ -206,13 +206,14 @@ def quantity_of_tests_critic(candidate_result: OptimizedCandidateResult | Origin
 def coverage_critic(original_code_coverage: CoverageData | None) -> bool:
     """Check if the coverage meets the threshold.
 
-    For languages without coverage support (like Java), returns True if no coverage data is available.
+    For languages without coverage support (like JavaScript), returns True if no coverage data is available.
+    Java now uses JaCoCo for coverage collection and is subject to coverage threshold checks.
     """
-    from codeflash.languages import is_java, is_javascript
+    from codeflash.languages import is_javascript
 
     if original_code_coverage:
         return original_code_coverage.coverage >= COVERAGE_THRESHOLD
-    # For Java/JavaScript, coverage is not implemented yet, so skip the check
-    if is_java() or is_javascript():
+    # For JavaScript, coverage is not implemented yet, so skip the check
+    if is_javascript():
         return True
     return False