fix: harden settings.gradle module detection and use exact test assertions

- Replace fragile multi-regex settings.gradle parser with a single broad
  pattern that extracts all quoted module identifiers, handling any DSL style
- Add _scan_filesystem_for_modules() as fallback when settings parsing fails
- Fix all test assertions to use full string equality (== []) not substring (in)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: HeshamHM28

codeflash/languages/java/test_runner.py

@@ -202,29 +202,43 @@ def _validate_test_filter(test_filter: str) -> str:
 def _extract_modules_from_settings_gradle(content: str) -> list[str]:
     """Extract module names from settings.gradle(.kts) content.
 
-    Handles several patterns:
-        include("module-a", "module-b")              // Kotlin DSL (single/multi-line)
-        include 'module-a', 'module-b'               // Groovy DSL
-        val projects = listOf("module-a", "module-b") // Kotlin variable lists
-    Module names may be prefixed with ':' which is stripped.
+    Collects every quoted string that looks like a Gradle module identifier
+    (word chars, hyphens, colons, dots).  This is intentionally broad so it
+    works regardless of DSL style — ``include("a")``, ``listOf("a")``,
+    variable-based indirection, etc.  False positives are harmless because
+    callers match module names against actual file paths.
     """
+    seen: set[str] = set()
     modules: list[str] = []
-    # Match include(...) calls, including multi-line ones
-    for match in re.findall(r"""include\s*\(([^)]*)\)""", content, re.DOTALL):
-        for name in re.findall(r"""['"]([^'"]+)['"]""", match):
-            modules.append(name.lstrip(":"))
-    # Match Groovy-style: include 'mod-a', 'mod-b' (no parens, single line)
-    for match in re.findall(r"""include\s+(?=['"])([^\n]+)""", content):
-        for name in re.findall(r"""['"]([^'"]+)['"]""", match):
-            clean = name.lstrip(":")
-            if clean not in modules:
-                modules.append(clean)
-    # Match Kotlin-style variable lists: val x = listOf("mod-a", "mod-b")
-    for match in re.findall(r"""listOf\s*\(([^)]*)\)""", content, re.DOTALL):
-        for name in re.findall(r"""['"]([^'"]+)['"]""", match):
-            clean = name.lstrip(":")
-            if clean not in modules:
-                modules.append(clean)
+    for name in re.findall(r"""['"]([:\w][\w.:-]*)['"]""", content):
+        clean = name.lstrip(":")
+        if clean and clean not in seen:
+            seen.add(clean)
+            modules.append(clean)
+    return modules
+
+
+def _scan_filesystem_for_modules(directory: Path) -> list[str]:
+    """Detect Gradle/Maven sub-modules by scanning for build files on disk.
+
+    Checks up to two directory levels (covers nested modules like
+    ``connect/runtime``).  This is a reliable fallback when the settings
+    file uses complex DSL that text-based parsing cannot handle.
+    """
+    modules: list[str] = []
+    _BUILD_FILES = ("build.gradle", "build.gradle.kts", "pom.xml")
+    for child in directory.iterdir():
+        if not child.is_dir() or child.name.startswith("."):
+            continue
+        if any((child / bf).exists() for bf in _BUILD_FILES):
+            modules.append(child.name)
+        # One level deeper for nested modules (connect/runtime)
+        for grandchild in child.iterdir():
+            if not grandchild.is_dir() or grandchild.name.startswith("."):
+                continue
+            if any((grandchild / bf).exists() for bf in _BUILD_FILES):
+                rel = grandchild.relative_to(directory)
+                modules.append(str(rel).replace(os.sep, ":"))
     return modules
 
 
@@ -251,7 +265,8 @@ def _detect_modules(directory: Path) -> list[str]:
             except Exception:
                 pass
 
-    return []
+    # Fallback: scan filesystem for directories with build files
+    return _scan_filesystem_for_modules(directory)
 
 
 def _is_build_root(directory: Path) -> bool:

tests/test_gradle_resolve_project_classpath.py

@@ -77,25 +77,24 @@ def test_replaces_missing_jars_with_class_dirs(strategy, build_root, tmp_path):
 
     entries = result.split(os.pathsep)
 
-    # Module A: JAR replaced with java/main classes + resources/main
+    ext_jar = str(tmp_path / "gradle-cache" / "some-lib-1.0.jar")
     mod_a_java = str(build_root / "module-a" / "build" / "classes" / "java" / "main")
     mod_a_resources = str(build_root / "module-a" / "build" / "resources" / "main")
-    assert mod_a_java in entries
-    assert mod_a_resources in entries
-
-    # Module B: JAR replaced with both kotlin/main and java/main classes
     mod_b_kotlin = str(build_root / "module-b" / "build" / "classes" / "kotlin" / "main")
     mod_b_java = str(build_root / "module-b" / "build" / "classes" / "java" / "main")
-    assert mod_b_kotlin in entries
-    assert mod_b_java in entries
-
-    # External JAR preserved as-is
-    ext_jar = str(tmp_path / "gradle-cache" / "some-lib-1.0.jar")
-    assert ext_jar in entries
-
-    # Original JAR paths should NOT be present
-    assert str(build_root / "module-a" / "build" / "libs" / "module-a-1.0.jar") not in entries
-    assert str(build_root / "module-b" / "build" / "libs" / "module-b-1.0.jar") not in entries
+    mod_c_java = str(build_root / "module-c" / "build" / "classes" / "java" / "main")
+
+    # Full equality: module-a JAR → java/main + resources/main,
+    # external JAR preserved, module-b JAR → kotlin/main + java/main,
+    # module-c JAR → java/main (compiled by mock)
+    assert entries == [
+        mod_a_java,
+        mod_a_resources,
+        ext_jar,
+        mod_b_kotlin,
+        mod_b_java,
+        mod_c_java,
+    ]
 
 
 def test_compiles_uncompiled_modules(strategy, build_root, tmp_path):

tests/test_languages/test_java/test_java_test_paths.py

@@ -489,46 +489,42 @@ class TestExtractModulesFromSettingsGradle:
     def test_simple_top_level_modules(self):
         content = """include("streams", "clients", "tools")"""
         modules = _extract_modules_from_settings_gradle(content)
-        assert "streams" in modules
-        assert "clients" in modules
-        assert "tools" in modules
+        assert modules == ["streams", "clients", "tools"]
 
     def test_nested_gradle_modules(self):
         """Nested modules like connect:runtime should be extracted."""
         content = """include("connect:runtime", "connect:api", "streams")"""
         modules = _extract_modules_from_settings_gradle(content)
-        assert "connect:runtime" in modules
-        assert "connect:api" in modules
-        assert "streams" in modules
+        assert modules == ["connect:runtime", "connect:api", "streams"]
 
     def test_leading_colon_stripped(self):
         content = """include(":streams", ":clients")"""
         modules = _extract_modules_from_settings_gradle(content)
-        assert "streams" in modules
-        assert "clients" in modules
+        assert modules == ["streams", "clients"]
 
     def test_multiline_include(self):
         """Multi-line include() calls should be parsed correctly."""
         content = 'include(\n    "rewrite-core",\n    "rewrite-java",\n    "rewrite-test"\n)'
         modules = _extract_modules_from_settings_gradle(content)
-        assert "rewrite-core" in modules
-        assert "rewrite-java" in modules
-        assert "rewrite-test" in modules
+        assert modules == ["rewrite-core", "rewrite-java", "rewrite-test"]
 
     def test_kotlin_listof_variable(self):
         """Kotlin-style val x = listOf(...) should be parsed for module names."""
         content = 'val allProjects = listOf(\n    "rewrite-core",\n    "rewrite-java",\n    "rewrite-test"\n)\ninclude(*(allProjects).toTypedArray())'
         modules = _extract_modules_from_settings_gradle(content)
-        assert "rewrite-core" in modules
-        assert "rewrite-java" in modules
-        assert "rewrite-test" in modules
+        assert modules == ["rewrite-core", "rewrite-java", "rewrite-test"]
 
     def test_groovy_include_without_parens(self):
         """Groovy-style include without parentheses."""
         content = "include 'streams', 'clients'"
         modules = _extract_modules_from_settings_gradle(content)
-        assert "streams" in modules
-        assert "clients" in modules
+        assert modules == ["streams", "clients"]
+
+    def test_deduplicates_modules(self):
+        """Same module referenced in listOf and include should appear once."""
+        content = 'val mods = listOf("core")\ninclude("core", "web")'
+        modules = _extract_modules_from_settings_gradle(content)
+        assert modules == ["core", "web"]
 
 
 class TestFindMultiModuleRoot: