⚡️ Speed up function _path_to_class_name by 18% in PR #1199 (omni-java)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1199

If you approve this dependent PR, these changes will be merged into the original PR branch omni-java.

This PR will be automatically closed if the original PR is merged.

---

📄 18% (0.18x) speedup for _path_to_class_name in codeflash/languages/java/test_runner.py

⏱️ Runtime : 240 microseconds → 204 microseconds (best of 249 runs)

📝 Explanation and details

The optimized code achieves a 17% runtime improvement (from 240μs to 204μs) through three targeted optimizations:

Key Optimizations

1. Faster file extension check (path.suffix == ".java" → path.name.endswith(".java")):

   • Line profiler shows this reduces time from 4.20ms to 2.32ms (~45% faster on this line)
   • path.suffix property access involves additional attribute lookups, while path.name.endswith() is a direct string operation
   • Test results show dramatic speedups for early-exit cases: non-Java files now return ~60-70% faster (e.g., test_non_java_extension_returns_none: 1.97μs → 1.20μs)

2. Avoiding unnecessary list conversion (list(path.parts) → path.parts):

   • Reduces line time from 2.58ms to 2.44ms
   • path.parts already returns a tuple which supports indexing and iteration
   • Creating a list copy is wasteful when we only need read-only access
   • The list conversion only happens later when needed: list(parts[java_idx + 1:])

3. Direct string slicing for extension removal (replace(".java", "") → [:-5]):

   • Reduces line time from 0.79ms to 0.62ms (~20% faster)
   • Since we've already verified the file ends with .java (exactly 5 characters), slicing is guaranteed safe
   • String slicing is inherently faster than .replace() which must search and allocate a new string

Performance Profile

The optimizations particularly benefit:

• Common case paths (Maven/Gradle structures): 15-23% faster across all standard layouts
• Early exit scenarios (non-.java files): 50-70% faster - crucial if this function filters many file types
• Deeply nested packages: Maintains consistent 15-20% improvement even with 200+ package levels

The line profiler confirms the heaviest operations (suffix check and parts iteration) remain dominant but are now more efficient, with the cumulative effect producing the 17% overall speedup.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 53 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

from __future__ import annotations

from pathlib import \
    Path  # used to construct path objects for the function inputs

# imports
import pytest  # used for our unit tests
from codeflash.languages.java.test_runner import _path_to_class_name

def test_non_java_extension_returns_none():
    # A file that does not end with .java should immediately return None
    p = Path("src/test/java/com/example/CalculatorTest.txt")
    codeflash_output = _path_to_class_name(p) # 1.97μs -> 1.20μs (64.1% faster)

def test_basic_maven_main_structure():
    # Standard Maven main/java layout should produce a dotted class name
    p = Path("project/src/main/java/com/example/CalculatorTest.java")
    # Expect package "com.example" + class name "CalculatorTest"
    codeflash_output = _path_to_class_name(p) # 5.73μs -> 4.96μs (15.5% faster)

def test_basic_maven_test_structure():
    # Standard Maven test/java layout should also produce a dotted class name
    p = Path("project/src/test/java/com/example/CalculatorTest.java")
    codeflash_output = _path_to_class_name(p) # 5.60μs -> 4.79μs (17.0% faster)

def test_last_java_fallback_when_no_main_or_test_prefix():
    # When there are multiple 'java' directories but none preceded by 'main' or 'test',
    # the logic should pick the last 'java' directory as the package root.
    p = Path("a/java/b/java/com/example/Foo.java")
    # The last 'java' is the second one; package begins after that -> com.example.Foo
    codeflash_output = _path_to_class_name(p) # 6.90μs -> 6.26μs (10.2% faster)

def test_prefers_main_or_test_java_over_other_java():
    # If a 'java' directory appears that is preceded by 'main' or 'test',
    # that should be preferred even if other 'java' directories exist elsewhere.
    p = Path("root/java/main/java/com/example/Foo.java")
    # The 'java' that follows 'main' should be used -> com.example.Foo
    codeflash_output = _path_to_class_name(p) # 5.66μs -> 4.84μs (17.0% faster)

def test_filename_with_multiple_dots_keeps_inner_dots():
    # Ensure only the trailing ".java" is removed and inner dots remain part of the class name.
    p = Path("src/test/java/com/example/My.Class.Test.java")
    # Name part "My.Class.Test.java" should become "My.Class.Test"
    codeflash_output = _path_to_class_name(p) # 5.54μs -> 4.65μs (19.2% faster)

def test_uppercase_extension_returns_none():
    # Suffix comparison is case-sensitive: "JAVA" should not be accepted as ".java"
    p = Path("src/test/java/com/example/CalculatorTest.JAVA")
    codeflash_output = _path_to_class_name(p) # 1.89μs -> 1.16μs (62.9% faster)

def test_no_java_directory_returns_stem():
    # If there is no 'java' directory component at all, fallback to using the file stem.
    p = Path("some/other/structure/Foo.java")
    # No 'java' in parts => fallback to stem (filename without extension)
    codeflash_output = _path_to_class_name(p) # 6.30μs -> 5.93μs (6.26% faster)

def test_windows_drive_style_path_handling():
    # Windows-style drive letter should not affect extraction; package starts after 'java'.
    # Construct a path that includes a drive prefix as a first component.
    p = Path("C:/project/src/main/java/com/example/FooTest.java")
    codeflash_output = _path_to_class_name(p) # 5.54μs -> 4.78μs (15.9% faster)

def test_relative_path_starting_with_java_is_handled():
    # If the path starts with 'java' (index 0), the first loop won't match because it checks i > 0.
    # The fallback that finds the last 'java' should still work, selecting index 0.
    p = Path("java/com/example/Foo.java")
    codeflash_output = _path_to_class_name(p) # 6.58μs -> 5.81μs (13.3% faster)

def test_path_with_similar_names_not_matching_java():
    # Directory names that include 'java' but are not exactly 'java' should not be treated as package roots.
    p = Path("src/test/javapack/com/example/Foo.java")
    # No exact 'java' component => fallback to stem
    codeflash_output = _path_to_class_name(p) # 6.24μs -> 5.76μs (8.35% faster)

def test_deep_package_structure_large_scale():
    # Large-scale test: construct many nested package components (but under 1000)
    # This checks scalability and correct joining for long package paths.
    num_segments = 200  # well under the 1000 element guideline
    segments = [f"p{i}" for i in range(num_segments)]
    # Prepend with a standard Maven layout so the extraction uses the first loop
    path_parts = ["project", "src", "main", "java"] + segments + ["MyHugeTest.java"]
    p = Path(*path_parts)
    # Expected result is the dot-joined package segments plus the class name
    expected = ".".join(segments + ["MyHugeTest"])
    codeflash_output = _path_to_class_name(p) # 8.97μs -> 7.93μs (13.0% faster)

def test_file_named_java_in_parent_but_not_directory():
    # If 'java' appears as part of a filename but not as a directory component, it should not be treated as a package root.
    # Create a path where a parent directory is named 'javafile' but there's also a 'java' segment earlier
    p = Path("some/javafile/com/example/Test.java")
    # There is no exact 'java' directory component -> fallback to stem
    codeflash_output = _path_to_class_name(p) # 6.16μs -> 5.90μs (4.44% faster)

def test_trailing_java_directory_with_file_after_it():
    # If 'java' is the last directory before the file, extraction should still work.
    p = Path("workspace/tools/java/TestPkg/TestClass.java")
    # The java directory is the one before TestPkg, so package should be 'TestPkg.TestClass'
    codeflash_output = _path_to_class_name(p) # 6.65μs -> 5.96μs (11.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from pathlib import Path

# imports
import pytest
from codeflash.languages.java.test_runner import _path_to_class_name

class TestBasicFunctionality:
    """Test basic, expected scenarios for _path_to_class_name."""

    def test_standard_maven_test_structure(self):
        """Test standard Maven project structure: src/test/java/com/example/TestClass.java"""
        path = Path("src/test/java/com/example/CalculatorTest.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.63μs -> 4.67μs (20.6% faster)

    def test_standard_maven_main_structure(self):
        """Test standard Maven project structure for main source: src/main/java/com/example/MyClass.java"""
        path = Path("src/main/java/com/example/Calculator.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.48μs -> 4.63μs (18.4% faster)

    def test_gradle_project_structure(self):
        """Test Gradle project structure: src/test/java/com/example/TestClass.java"""
        path = Path("src/test/java/org/gradle/MyTest.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.41μs -> 4.63μs (16.9% faster)

    def test_deeply_nested_package(self):
        """Test deeply nested package structure with many package levels"""
        path = Path("src/test/java/com/example/service/impl/util/CalculatorTest.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.74μs -> 4.74μs (21.1% faster)

    def test_single_level_package(self):
        """Test package with single level: src/test/java/MyTest.java"""
        path = Path("src/test/java/MyTest.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.32μs -> 4.32μs (23.2% faster)

    def test_simple_class_name(self):
        """Test simple class name without package structure"""
        path = Path("SimpleTest.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.84μs -> 5.41μs (7.97% faster)

    def test_non_java_file_returns_none(self):
        """Test that non-.java files return None"""
        path = Path("src/test/java/com/example/Test.txt")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 1.89μs -> 1.11μs (70.5% faster)

    def test_python_file_returns_none(self):
        """Test that .py files return None"""
        path = Path("src/test/java/com/example/test.py")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 1.77μs -> 1.15μs (53.9% faster)

    def test_class_with_uppercase_letters(self):
        """Test class names with mixed case (typical Java convention)"""
        path = Path("src/main/java/com/example/MyApplicationTest.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.72μs -> 4.70μs (21.7% faster)

class TestEdgeCases:
    """Test edge cases and unusual scenarios."""

    def test_empty_path(self):
        """Test behavior with empty path components"""
        path = Path("Test.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.77μs -> 5.37μs (7.47% faster)

    def test_path_with_multiple_java_directories(self):
        """Test path containing 'java' in multiple locations"""
        # Should find the one after 'main' or 'test' first
        path = Path("java/src/test/java/com/example/Test.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.69μs -> 4.85μs (17.3% faster)

    def test_path_with_java_but_no_main_or_test(self):
        """Test path with 'java' directory not preceded by 'main' or 'test'"""
        path = Path("projects/java/com/example/Calculator.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 6.75μs -> 5.91μs (14.2% faster)

    def test_class_name_with_numbers(self):
        """Test class names containing numbers"""
        path = Path("src/test/java/com/example/Test2Factory.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.37μs -> 4.51μs (19.1% faster)

    def test_package_with_numbers(self):
        """Test package components containing numbers"""
        path = Path("src/test/java/com/example2/service3/Test.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.38μs -> 4.65μs (15.7% faster)

    def test_class_name_with_underscores(self):
        """Test class names containing underscores"""
        path = Path("src/test/java/com/example/My_Test_Class.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.56μs -> 4.38μs (27.0% faster)

    def test_uppercase_java_extension(self):
        """Test that uppercase .JAVA extension is not recognized"""
        path = Path("src/test/java/com/example/Test.JAVA")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 1.88μs -> 1.14μs (64.8% faster)

    def test_mixed_case_java_extension(self):
        """Test that mixed case .Java extension is not recognized"""
        path = Path("src/test/java/com/example/Test.Java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 1.83μs -> 1.20μs (52.5% faster)

    def test_path_with_dots_in_directory_names(self):
        """Test path with dots in directory names (not extension)"""
        path = Path("src/test/java/com.example.v1/util/Test.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.64μs -> 4.59μs (22.9% faster)

    def test_class_file_without_extension(self):
        """Test file without .java extension but with java-like name"""
        path = Path("src/test/java/com/example/TestClass")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 1.54μs -> 1.13μs (36.3% faster)

    def test_path_with_trailing_slash(self):
        """Test path object behavior with directory-like paths"""
        # Path objects handle trailing slashes naturally
        path = Path("src/test/java/com/example/Test.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.40μs -> 4.61μs (17.2% faster)

    def test_single_character_class_name(self):
        """Test single-character class names"""
        path = Path("src/test/java/com/example/A.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.22μs -> 4.45μs (17.3% faster)

    def test_single_character_package_names(self):
        """Test single-character package components"""
        path = Path("src/test/java/a/b/c/Test.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.48μs -> 4.62μs (18.7% faster)

    def test_very_long_class_name(self):
        """Test very long class name"""
        long_name = "VeryLongClassNameWithManyCharactersThatStillShouldBeValid.java"
        path = Path(f"src/test/java/com/example/{long_name}")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.72μs -> 4.50μs (27.2% faster)

    def test_class_name_ending_with_test(self):
        """Test class names ending with 'Test' (common convention)"""
        path = Path("src/test/java/com/example/CalculatorTest.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.33μs -> 4.57μs (16.7% faster)

    def test_class_name_with_impl_suffix(self):
        """Test class names with implementation suffix"""
        path = Path("src/main/java/com/example/CalculatorImpl.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.32μs -> 4.43μs (20.1% faster)

    def test_class_name_with_factory_suffix(self):
        """Test class names with Factory suffix"""
        path = Path("src/main/java/com/example/ObjectFactory.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.33μs -> 4.45μs (19.8% faster)

    def test_windows_style_path(self):
        """Test Windows-style path with backslashes"""
        # Path object normalizes separators
        path = Path("src\\test\\java\\com\\example\\Test.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.89μs -> 5.42μs (8.71% faster)

    def test_path_with_consecutive_slashes(self):
        """Test path with unusual separator patterns"""
        # Path normalizes consecutive separators
        path = Path("src/test/java/com/example/Test.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.47μs -> 4.61μs (18.7% faster)

    def test_file_with_multiple_dots(self):
        """Test file with multiple dots in name (only last is extension)"""
        path = Path("src/test/java/com/example/Test.util.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.40μs -> 4.54μs (19.0% faster)

    def test_class_name_with_dollar_sign(self):
        """Test inner class names with dollar signs"""
        path = Path("src/test/java/com/example/OuterClass$InnerTest.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.52μs -> 4.54μs (21.6% faster)

class TestLargeScale:
    """Test performance and scalability with larger datasets."""

    def test_multiple_deeply_nested_paths(self):
        """Test processing many paths with deep nesting (scalability check)"""
        # Create 100 different deeply nested paths and process them
        test_paths = [
            Path(f"src/test/java/com/example/service/impl/util/level{i}/Test{i}.java")
            for i in range(100)
        ]
        results = [_path_to_class_name(path) for path in test_paths]
        for i, result in enumerate(results):
            pass

    def test_very_deeply_nested_single_path(self):
        """Test single path with extremely deep nesting (50 levels)"""
        # Build a path with 50 package levels
        package_parts = "/".join([f"level{i}" for i in range(50)])
        path = Path(f"src/test/java/{package_parts}/TestClass.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 6.48μs -> 5.61μs (15.5% faster)
        
        expected_parts = [f"level{i}" for i in range(50)] + ["TestClass"]
        expected = ".".join(expected_parts)

    def test_many_non_java_files_mixed(self):
        """Test processing many files with mixed extensions (scalability check)"""
        # Create mix of .java and non-.java files
        paths = []
        for i in range(50):
            paths.append(Path(f"src/test/java/com/example/Test{i}.java"))
            paths.append(Path(f"src/test/resources/config{i}.xml"))
            paths.append(Path(f"src/test/python/test{i}.py"))
        
        results = [_path_to_class_name(path) for path in paths]
        
        # Count non-None results (should be 50, one for each .java file)
        non_none_results = [r for r in results if r is not None]

    def test_paths_with_very_long_package_names(self):
        """Test paths with extremely long package component names"""
        long_package_name = "a" * 200  # 200-character package name
        path = Path(f"src/test/java/{long_package_name}/Test.java")
        codeflash_output = _path_to_class_name(path); result = codeflash_output # 5.61μs -> 4.67μs (20.2% faster)

    def test_batch_processing_varying_depths(self):
        """Test processing batch of paths with varying nesting depths"""
        paths = [
            Path("Test.java"),  # depth 0
            Path("src/test/java/Test.java"),  # depth 3
            Path("src/test/java/com/Test.java"),  # depth 4
            Path("src/test/java/com/example/Test.java"),  # depth 5
            Path("src/test/java/com/example/service/impl/Test.java"),  # depth 6
        ]
        
        expected_results = [
            "Test",
            "Test",
            "com.Test",
            "com.example.Test",
            "com.example.service.impl.Test",
        ]
        
        results = [_path_to_class_name(path) for path in paths]

    def test_large_number_of_sequential_calls(self):
        """Test performance with 500 sequential function calls"""
        path = Path("src/test/java/com/example/Test.java")
        # Call the function 500 times with the same path
        results = [_path_to_class_name(path) for _ in range(500)]

    def test_many_classes_same_package(self):
        """Test processing many classes in the same package"""
        paths = [
            Path(f"src/test/java/com/example/Test{i}.java")
            for i in range(200)
        ]
        results = [_path_to_class_name(path) for path in paths]
        for i, result in enumerate(results):
            pass

    def test_many_packages_many_classes(self):
        """Test processing many classes across many different packages"""
        paths = []
        for pkg_idx in range(20):
            for class_idx in range(20):
                paths.append(
                    Path(f"src/test/java/org/example/pkg{pkg_idx}/Class{class_idx}.java")
                )
        
        results = [_path_to_class_name(path) for path in paths]

    def test_performance_idempotency(self):
        """Test that repeated calls produce identical results consistently"""
        paths = [
            Path(f"src/test/java/com/example/service/Test{i}.java")
            for i in range(100)
        ]
        
        # Call twice and compare
        results1 = [_path_to_class_name(path) for path in paths]
        results2 = [_path_to_class_name(path) for path in paths]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr1199-2026-02-03T14.18.53 and push.

[KRRT7]

Closing stale bot PR.