fix: improve Java test file handling and JaCoCo coverage for multi-module projects

- Fix duplicate test file issue: when multiple tests have the same class name,
  append unique index suffix (e.g., CryptoTest_2) to avoid file overwrites
- Fix multi-module JaCoCo support: add JaCoCo plugin to test module's pom.xml
  instead of source module, ensuring coverage data is collected where tests run
- Fix timeout: use minimum 60s (120s with coverage) for Java builds since Maven
  takes longer than the default 15s INDIVIDUAL_TESTCASE_TIMEOUT
- Fix Maven phase: use 'verify' instead of 'test' when coverage is enabled,
  with maven.test.failure.ignore=true to generate report even if tests fail
- Update JaCoCo report phase from 'test' to 'verify' to run after tests complete

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

Author: misrasaurabh1

codeflash/languages/java/build_tools.py

@@ -720,7 +720,7 @@ def add_jacoco_plugin_to_pom(pom_path: Path) -> bool:
           </execution>
           <execution>
             <id>report</id>
-            <phase>test</phase>
+            <phase>verify</phase>
             <goals>
               <goal>report</goal>
             </goals>

codeflash/languages/java/test_runner.py

@@ -183,22 +183,36 @@ def run_behavioral_tests(
     run_env["CODEFLASH_OUTPUT_FILE"] = str(sqlite_db_path)  # SQLite output path
 
     # If coverage is enabled, ensure JaCoCo is configured
-    # For multi-module projects, add JaCoCo to the source module (project_root), not the test module
+    # For multi-module projects, add JaCoCo to the test module's pom.xml (where tests run)
     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)
+        # Determine which pom.xml to configure JaCoCo in
+        if test_module:
+            # Multi-module project: add JaCoCo to test module
+            test_module_pom = maven_root / test_module / "pom.xml"
+            if test_module_pom.exists():
+                if not is_jacoco_configured(test_module_pom):
+                    logger.info(f"Adding JaCoCo plugin to test module pom.xml: {test_module_pom}")
+                    add_jacoco_plugin_to_pom(test_module_pom)
+                coverage_xml_path = get_jacoco_xml_path(maven_root / test_module)
+        else:
+            # Single module project
+            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 from the appropriate root
+    # Use a minimum timeout of 60s for Java builds (120s when coverage is enabled due to verify phase)
+    min_timeout = 120 if enable_coverage else 60
+    effective_timeout = max(timeout or 300, min_timeout)
     result = _run_maven_tests(
         maven_root,
         test_paths,
         run_env,
-        timeout=timeout or 300,
+        timeout=effective_timeout,
         mode="behavior",
         enable_coverage=enable_coverage,
         test_module=test_module,
@@ -464,9 +478,14 @@ def _run_maven_tests(
     test_filter = _build_test_filter(test_paths, mode=mode)
 
     # Build Maven command
-    # Note: JaCoCo report is generated automatically during test phase via plugin execution binding
-    # We don't need to call jacoco:report explicitly since the plugin config binds it to test phase
-    cmd = [mvn, "test", "-fae"]  # Fail at end to run all tests
+    # When coverage is enabled, use 'verify' phase to ensure JaCoCo report runs after tests
+    # JaCoCo's report goal is bound to the verify phase to get post-test execution data
+    maven_goal = "verify" if enable_coverage else "test"
+    cmd = [mvn, maven_goal, "-fae"]  # Fail at end to run all tests
+
+    # When coverage is enabled, continue build even if tests fail so JaCoCo report is generated
+    if enable_coverage:
+        cmd.append("-Dmaven.test.failure.ignore=true")
 
     # For multi-module projects, specify which module to test
     if test_module:

codeflash/optimization/function_optimizer.py

@@ -576,18 +576,23 @@ def generate_and_instrument_tests(
             generated_tests = normalize_generated_tests_imports(generated_tests)
 
         logger.debug(f"[PIPELINE] Processing {count_tests} generated tests")
+        used_behavior_paths: set[Path] = set()
         for i, generated_test in enumerate(generated_tests.generated_tests):
             behavior_path = generated_test.behavior_file_path
             perf_path = generated_test.perf_file_path
 
             # For Java, fix paths to match package structure
             if is_java():
-                behavior_path, perf_path = self._fix_java_test_paths(
+                behavior_path, perf_path, modified_behavior_source, modified_perf_source = self._fix_java_test_paths(
                     generated_test.instrumented_behavior_test_source,
                     generated_test.instrumented_perf_test_source,
+                    used_behavior_paths,
                 )
                 generated_test.behavior_file_path = behavior_path
                 generated_test.perf_file_path = perf_path
+                generated_test.instrumented_behavior_test_source = modified_behavior_source
+                generated_test.instrumented_perf_test_source = modified_perf_source
+                used_behavior_paths.add(behavior_path)
 
             logger.debug(
                 f"[PIPELINE] Test {i + 1}: behavior_path={behavior_path}, perf_path={perf_path}"
@@ -653,20 +658,23 @@ def generate_and_instrument_tests(
         )
 
     def _fix_java_test_paths(
-        self, behavior_source: str, perf_source: str
-    ) -> tuple[Path, Path]:
+        self, behavior_source: str, perf_source: str, used_paths: set[Path]
+    ) -> tuple[Path, Path, str, str]:
         """Fix Java test file paths to match package structure.
 
         Java requires test files to be in directories matching their package.
         This method extracts the package and class from the generated tests
-        and returns correct paths.
+        and returns correct paths. If the path would conflict with an already
+        used path, it renames the class by adding an index suffix.
 
         Args:
             behavior_source: Source code of the behavior test.
             perf_source: Source code of the performance test.
+            used_paths: Set of already used behavior file paths.
 
         Returns:
-            Tuple of (behavior_path, perf_path) with correct package structure.
+            Tuple of (behavior_path, perf_path, modified_behavior_source, modified_perf_source)
+            with correct package structure and unique class names.
 
         """
         import re
@@ -692,15 +700,55 @@ def _fix_java_test_paths(
             behavior_path = test_dir / package_path / f"{behavior_class}.java"
             perf_path = test_dir / package_path / f"{perf_class}.java"
         else:
+            package_path = ""
             behavior_path = test_dir / f"{behavior_class}.java"
             perf_path = test_dir / f"{perf_class}.java"
 
+        # If path already used, rename class by adding index suffix
+        modified_behavior_source = behavior_source
+        modified_perf_source = perf_source
+        if behavior_path in used_paths:
+            # Find a unique index
+            index = 2
+            while True:
+                new_behavior_class = f"{behavior_class}_{index}"
+                new_perf_class = f"{perf_class}_{index}"
+                if package_path:
+                    new_behavior_path = test_dir / package_path / f"{new_behavior_class}.java"
+                    new_perf_path = test_dir / package_path / f"{new_perf_class}.java"
+                else:
+                    new_behavior_path = test_dir / f"{new_behavior_class}.java"
+                    new_perf_path = test_dir / f"{new_perf_class}.java"
+                if new_behavior_path not in used_paths:
+                    behavior_path = new_behavior_path
+                    perf_path = new_perf_path
+                    # Rename class in source code - replace the class declaration
+                    modified_behavior_source = re.sub(
+                        rf'^((?:public\s+)?class\s+){re.escape(behavior_class)}(\b)',
+                        rf'\g<1>{new_behavior_class}\g<2>',
+                        behavior_source,
+                        count=1,
+                        flags=re.MULTILINE,
+                    )
+                    modified_perf_source = re.sub(
+                        rf'^((?:public\s+)?class\s+){re.escape(perf_class)}(\b)',
+                        rf'\g<1>{new_perf_class}\g<2>',
+                        perf_source,
+                        count=1,
+                        flags=re.MULTILINE,
+                    )
+                    logger.debug(
+                        f"[JAVA] Renamed duplicate test class from {behavior_class} to {new_behavior_class}"
+                    )
+                    break
+                index += 1
+
         # Create directories if needed
         behavior_path.parent.mkdir(parents=True, exist_ok=True)
         perf_path.parent.mkdir(parents=True, exist_ok=True)
 
         logger.debug(f"[JAVA] Fixed paths: behavior={behavior_path}, perf={perf_path}")
-        return behavior_path, perf_path
+        return behavior_path, perf_path, modified_behavior_source, modified_perf_source
 
     # note: this isn't called by the lsp, only called by cli
     def optimize_function(self) -> Result[BestOptimization, str]: