⚡️ Speed up function _build_test_filter by 34% in PR #1345 (debug/java-test-filter)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1345

If you approve this dependent PR, these changes will be merged into the original PR branch debug/java-test-filter.

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

---

📄 34% (0.34x) speedup for _build_test_filter in codeflash/languages/java/test_runner.py

⏱️ Runtime : 53.4 milliseconds → 39.9 milliseconds (best of 43 runs)

📝 Explanation and details

The optimized code achieves a 33% runtime improvement (53.4ms → 39.9ms) through three targeted optimizations:

Primary Optimizations

1. Hoisted mode comparison (accounts for most of the speedup)

is_performance_mode = mode == "performance"

This moves the string comparison mode == "performance" outside the loop, avoiding repeated string comparisons for every test file. In the line profiler, this changes line 29 from 113ms to 90ms per iteration, saving ~20% per loop iteration. With hundreds of test files processed, this accumulates to significant savings.

2. Optimized loop in _path_to_class_name

# Original: for i, part in enumerate(parts)
# Optimized: for i in range(1, len(parts))

The original enumerate() creates iterator objects and unpacks tuples on each iteration. The optimized version uses direct range indexing, which is more efficient for this specific use case where we start at index 1 and need the index anyway.

3. Eliminated redundant list() conversion

# Original: parts = list(path.parts)
# Optimized: parts = path.parts

path.parts already returns a tuple, which is sufficient for indexing operations. The explicit list() conversion added unnecessary overhead (1.16ms → 1.11ms in line profiler).

4. Deferred warning logs
The optimization defers logger.warning() calls until after the loop when all tests are skipped, checking reasons in a separate loop. While this adds a small overhead in error cases (the new loop at lines 64-66), it significantly reduces logging overhead in the common path where some tests succeed. The line profiler shows the massive reduction in time spent on warning calls (90ms → 0ms for inline warnings during the loop).

Performance Characteristics

Based on the annotated tests, this optimization excels when:

• Processing TestFiles objects with many test files (e.g., 4555% faster for behavior mode, 4869% faster for performance mode)
• Handling mixed valid/invalid paths (5720% faster with partial invalid paths)
• Converting standard Maven/Gradle path structures

The optimization maintains correctness while achieving dramatic speedups in scenarios where the function processes multiple test files through the TestFiles object path, which appears to be the primary use case given the substantial improvements in those specific test scenarios.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from pathlib import Path
from types import SimpleNamespace

# imports
import pytest  # used for our unit tests
# Import the real functions under test from the provided module path.
# The tests rely on the real implementation; do not redefine the functions.
from codeflash.languages.java.test_runner import (_build_test_filter,
                                                  _path_to_class_name)

def test_empty_inputs_return_empty_string():
    # None should be treated as empty -> return empty filter
    codeflash_output = _build_test_filter(None) # 1.29μs -> 1.74μs (25.9% slower)
    # Empty list should return empty filter
    codeflash_output = _build_test_filter([]) # 531ns -> 551ns (3.63% slower)
    # Empty tuple should return empty filter
    codeflash_output = _build_test_filter(()) # 391ns -> 391ns (0.000% faster)
    # Empty string is falsy and should also return empty filter
    codeflash_output = _build_test_filter("") # 411ns -> 381ns (7.87% faster)

def test_list_of_strings_and_paths_converted_and_joined():
    # Path that maps to a package class name using standard maven structure
    p = Path("src/test/java/com/example/CalculatorTest.java")
    # A plain string test spec should be preserved as-is
    s = "com.other.SomeTest"
    # Mixed input: Path and string -> order preserved
    codeflash_output = _build_test_filter([p, s]); result = codeflash_output # 8.46μs -> 9.44μs (10.4% slower)

def test_list_with_non_java_path_is_ignored():
    # A Path with a non-java suffix should not produce a filter entry
    p_txt = Path("src/test/java/com/example/NotJava.txt")
    # The list handling branch will only append strings or converted java class names.
    # Since p_txt cannot be converted to a class name, the resulting filter should be empty.
    codeflash_output = _build_test_filter([p_txt]) # 7.01μs -> 7.39μs (5.15% slower)

def test_nonstandard_path_falls_back_to_stem():
    # Path with no 'java' directory should fallback to using the stem (file name without extension)
    p = Path("some/random/CalculatorTest.java")
    # Ensure the main function uses that same conversion when passed as a list element
    codeflash_output = _build_test_filter([p]) # 8.50μs -> 8.52μs (0.223% slower)

def test_testfiles_behavior_mode_uses_instrumented_behavior_path():
    # One TestFile with valid instrumented_behavior_file_path and one without.
    valid = SimpleNamespace(
        original_file_path=Path("original/A.java"),
        instrumented_behavior_file_path=Path("src/test/java/org/example/BehaviorTest.java"),
        benchmarking_file_path=None,
    )
    missing = SimpleNamespace(
        original_file_path=Path("original/B.java"),
        instrumented_behavior_file_path=None,
        benchmarking_file_path=None,
    )
    test_files_container = SimpleNamespace(test_files=[valid, missing])

    # Behavior mode: only the valid instrumented_behavior_file_path contributes
    codeflash_output = _build_test_filter(test_files_container, mode="behavior"); out = codeflash_output # 618μs -> 13.3μs (4555% faster)

def test_testfiles_performance_mode_prefers_benchmarking_path():
    # Two TestFile entries: one has benchmarking path, one does not
    bench = SimpleNamespace(
        original_file_path=Path("original/C.java"),
        instrumented_behavior_file_path=None,
        benchmarking_file_path=Path("src/test/java/org/perf/PerfTest.java"),
    )
    no_bench = SimpleNamespace(
        original_file_path=Path("original/D.java"),
        instrumented_behavior_file_path=Path("src/test/java/org/behavior/ShouldNotBeUsed.java"),
        benchmarking_file_path=None,
    )
    container = SimpleNamespace(test_files=[bench, no_bench])

    # In performance mode, only benchmarking_file_path is considered
    codeflash_output = _build_test_filter(container, mode="performance"); out = codeflash_output # 593μs -> 12.0μs (4869% faster)

def test_testfiles_all_skipped_returns_empty_string_and_handles_nonjava_files():
    # Both test files will be skipped: one because its instrumented_behavior_file_path is non-java,
    # the other because instrumented_behavior_file_path is missing.
    tf1 = SimpleNamespace(
        original_file_path=Path("orig/1.java"),
        instrumented_behavior_file_path=Path("src/test/java/org/example/NotJava.txt"),  # non-java suffix
        benchmarking_file_path=None,
    )
    tf2 = SimpleNamespace(
        original_file_path=Path("orig/2.java"),
        instrumented_behavior_file_path=None,
        benchmarking_file_path=None,
    )
    container = SimpleNamespace(test_files=[tf1, tf2])

    # Since behavior mode default is used and none produce a valid class name, result is empty string
    codeflash_output = _build_test_filter(container, mode="behavior") # 1.40ms -> 1.46ms (4.42% slower)

def test_path_to_class_name_with_main_or_test_prefix():
    # Typical Gradle/Maven structures: 'main/java' and 'test/java' should be detected
    p1 = Path("project/main/java/org/company/MainTest.java")
    p2 = Path("project/test/java/com/example/TestIt.java")

def test_path_to_class_name_uses_last_java_if_no_main_or_test():
    # If 'java' is present but not preceded by main/test, use the last 'java' occurrence
    p = Path("/upto/java/src/com/example/LastJavaTest.java")

def test_path_to_class_name_non_java_extension_returns_none():
    # Non .java suffix should return None
    p = Path("src/test/java/com/example/NotJava.kt")

def test_unknown_input_type_returns_empty_string():
    # Passing an integer should fall through to the final branch and return empty string
    codeflash_output = _build_test_filter(12345) # 2.71μs -> 3.12μs (13.2% slower)

def test_large_scale_list_of_strings_performance_and_correctness():
    # Generate 500 distinct test class strings and ensure they are all present in the output
    count = 500
    items = [f"com.example.LargeTest{idx}" for idx in range(count)]
    codeflash_output = _build_test_filter(items); result = codeflash_output # 44.4μs -> 45.6μs (2.59% slower)
    # The result should be the comma-joined strings in order
    expected = ",".join(items)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import logging
from pathlib import Path
from unittest.mock import MagicMock, Mock

import pytest
# Import the function to test
from codeflash.languages.java.test_runner import (_build_test_filter,
                                                  _path_to_class_name)

class TestBuildTestFilterBasic:
    """Basic test cases for _build_test_filter function."""

    def test_empty_list_input(self):
        """Test that empty list returns empty string."""
        codeflash_output = _build_test_filter([]); result = codeflash_output # 1.39μs -> 1.38μs (0.723% faster)

    def test_empty_tuple_input(self):
        """Test that empty tuple returns empty string."""
        codeflash_output = _build_test_filter(()); result = codeflash_output # 1.24μs -> 1.21μs (2.39% faster)

    def test_none_input(self):
        """Test that None input returns empty string."""
        codeflash_output = _build_test_filter(None); result = codeflash_output # 1.18μs -> 1.28μs (7.72% slower)

    def test_single_string_in_list(self):
        """Test single string element in list."""
        codeflash_output = _build_test_filter(["com.example.TestClass"]); result = codeflash_output # 2.60μs -> 2.73μs (4.75% slower)

    def test_multiple_strings_in_list(self):
        """Test multiple string elements in list joined by comma."""
        codeflash_output = _build_test_filter(["com.example.Test1", "com.example.Test2"]); result = codeflash_output # 2.73μs -> 2.82μs (3.23% slower)

    def test_single_path_object(self):
        """Test single Path object conversion to class name."""
        path = Path("src/test/java/com/example/TestClass.java")
        codeflash_output = _build_test_filter([path]); result = codeflash_output # 8.19μs -> 8.71μs (5.97% slower)

    def test_multiple_path_objects(self):
        """Test multiple Path objects conversion."""
        paths = [
            Path("src/test/java/com/example/Test1.java"),
            Path("src/test/java/com/example/Test2.java")
        ]
        codeflash_output = _build_test_filter(paths); result = codeflash_output # 10.2μs -> 11.2μs (8.51% slower)

    def test_mixed_strings_and_paths(self):
        """Test mix of string and Path objects."""
        items = [
            "com.example.StringTest",
            Path("src/test/java/com/example/PathTest.java")
        ]
        codeflash_output = _build_test_filter(items); result = codeflash_output # 7.73μs -> 8.40μs (7.98% slower)

    def test_behavior_mode_default(self):
        """Test default mode is 'behavior'."""
        mock_test_file = Mock()
        mock_test_file.instrumented_behavior_file_path = Path("src/test/java/com/example/Test.java")
        mock_test_file.original_file_path = Path("src/test/java/com/example/Test.java")

        mock_test_files = Mock()
        mock_test_files.test_files = [mock_test_file]

        codeflash_output = _build_test_filter(mock_test_files); result = codeflash_output # 10.4μs -> 10.9μs (4.13% slower)

    def test_behavior_mode_explicit(self):
        """Test explicit 'behavior' mode."""
        mock_test_file = Mock()
        mock_test_file.instrumented_behavior_file_path = Path("src/test/java/com/example/Test.java")
        mock_test_file.original_file_path = Path("src/test/java/com/example/Test.java")

        mock_test_files = Mock()
        mock_test_files.test_files = [mock_test_file]

        codeflash_output = _build_test_filter(mock_test_files, mode="behavior"); result = codeflash_output # 9.94μs -> 11.0μs (9.32% slower)

    def test_performance_mode(self):
        """Test 'performance' mode uses benchmarking_file_path."""
        mock_test_file = Mock()
        mock_test_file.benchmarking_file_path = Path("src/test/java/com/example/BenchmarkTest.java")
        mock_test_file.original_file_path = Path("src/test/java/com/example/BenchmarkTest.java")

        mock_test_files = Mock()
        mock_test_files.test_files = [mock_test_file]

        codeflash_output = _build_test_filter(mock_test_files, mode="performance"); result = codeflash_output # 10.2μs -> 11.1μs (7.78% slower)

class TestBuildTestFilterEdgeCases:
    """Edge case tests for _build_test_filter function."""

    def test_empty_string_in_list(self):
        """Test that empty string in list is included but results in just comma separation."""
        codeflash_output = _build_test_filter(["com.example.Test", "", "com.example.Test2"]); result = codeflash_output # 3.04μs -> 3.11μs (1.96% slower)

    def test_path_without_java_extension(self):
        """Test that non-.java files return None from path conversion."""
        path = Path("src/test/resources/TestData.txt")
        codeflash_output = _build_test_filter([path]); result = codeflash_output # 7.18μs -> 7.48μs (4.01% slower)

    def test_path_without_maven_structure(self):
        """Test path that doesn't contain standard Maven directory structure."""
        path = Path("somewhere/MyTest.java")
        codeflash_output = _build_test_filter([path]); result = codeflash_output # 8.11μs -> 8.45μs (4.04% slower)

    def test_deeply_nested_path(self):
        """Test deeply nested package structure."""
        path = Path("src/test/java/com/example/subpackage/deeppackage/MyTest.java")
        codeflash_output = _build_test_filter([path]); result = codeflash_output # 7.74μs -> 8.01μs (3.26% slower)

    def test_path_with_multiple_java_directories(self):
        """Test path with multiple 'java' directories uses the one after 'test'."""
        path = Path("src/test/java/com/java/example/TestClass.java")
        codeflash_output = _build_test_filter([path]); result = codeflash_output # 7.67μs -> 7.99μs (3.88% slower)

    def test_testfiles_with_none_behavior_path(self):
        """Test TestFile with None instrumented_behavior_file_path in behavior mode."""
        mock_test_file = Mock()
        mock_test_file.instrumented_behavior_file_path = None
        mock_test_file.original_file_path = Path("src/test/java/com/example/Test.java")

        mock_test_files = Mock()
        mock_test_files.test_files = [mock_test_file]

        codeflash_output = _build_test_filter(mock_test_files, mode="behavior"); result = codeflash_output # 1.40ms -> 1.44ms (2.45% slower)

    def test_testfiles_with_missing_behavior_attribute(self):
        """Test TestFile without instrumented_behavior_file_path attribute."""
        mock_test_file = Mock(spec=[])  # spec=[] means no attributes
        mock_test_file.original_file_path = Path("src/test/java/com/example/Test.java")

        mock_test_files = Mock()
        mock_test_files.test_files = [mock_test_file]

        codeflash_output = _build_test_filter(mock_test_files, mode="behavior"); result = codeflash_output # 1.38ms -> 1.41ms (2.44% slower)

    def test_testfiles_with_none_benchmarking_path(self):
        """Test TestFile with None benchmarking_file_path in performance mode."""
        mock_test_file = Mock()
        mock_test_file.benchmarking_file_path = None
        mock_test_file.original_file_path = Path("src/test/java/com/example/Test.java")

        mock_test_files = Mock()
        mock_test_files.test_files = [mock_test_file]

        codeflash_output = _build_test_filter(mock_test_files, mode="performance"); result = codeflash_output # 1.36ms -> 1.40ms (2.80% slower)

    def test_testfiles_with_missing_benchmarking_attribute(self):
        """Test TestFile without benchmarking_file_path attribute."""
        mock_test_file = Mock(spec=[])  # spec=[] means no attributes
        mock_test_file.original_file_path = Path("src/test/java/com/example/Test.java")

        mock_test_files = Mock()
        mock_test_files.test_files = [mock_test_file]

        codeflash_output = _build_test_filter(mock_test_files, mode="performance"); result = codeflash_output # 1.36ms -> 1.38ms (1.44% slower)

    def test_testfiles_mixed_valid_and_invalid_paths(self):
        """Test TestFiles with some valid and some invalid paths."""
        mock_test_file1 = Mock()
        mock_test_file1.instrumented_behavior_file_path = Path("src/test/java/com/example/Test1.java")
        mock_test_file1.original_file_path = Path("src/test/java/com/example/Test1.java")

        mock_test_file2 = Mock()
        mock_test_file2.instrumented_behavior_file_path = None
        mock_test_file2.original_file_path = Path("src/test/java/com/example/Test2.java")

        mock_test_file3 = Mock()
        mock_test_file3.instrumented_behavior_file_path = Path("src/test/java/com/example/Test3.java")
        mock_test_file3.original_file_path = Path("src/test/java/com/example/Test3.java")

        mock_test_files = Mock()
        mock_test_files.test_files = [mock_test_file1, mock_test_file2, mock_test_file3]

        codeflash_output = _build_test_filter(mock_test_files, mode="behavior"); result = codeflash_output # 659μs -> 17.6μs (3637% faster)

    def test_unknown_input_type(self):
        """Test with an unknown input type that doesn't have test_files attribute."""
        codeflash_output = _build_test_filter(42); result = codeflash_output # 2.79μs -> 3.22μs (13.4% slower)

    def test_string_input_alone(self):
        """Test that a single string (not in a list) is treated as unknown type."""
        codeflash_output = _build_test_filter("com.example.Test"); result = codeflash_output # 2.65μs -> 2.90μs (8.32% slower)

    def test_path_with_only_java_no_test_main_prefix(self):
        """Test path with 'java' but not after 'main' or 'test'."""
        path = Path("src/java/com/example/Test.java")
        codeflash_output = _build_test_filter([path]); result = codeflash_output # 9.74μs -> 9.49μs (2.65% faster)

    def test_testfiles_with_invalid_path_conversion(self):
        """Test TestFile where path cannot be converted to class name."""
        mock_test_file = Mock()
        mock_test_file.instrumented_behavior_file_path = Path("test.txt")  # No .java extension
        mock_test_file.original_file_path = Path("src/test/java/com/example/Test.java")

        mock_test_files = Mock()
        mock_test_files.test_files = [mock_test_file]

        codeflash_output = _build_test_filter(mock_test_files, mode="behavior"); result = codeflash_output # 712μs -> 725μs (1.79% slower)

    def test_path_with_dots_in_directory_names(self):
        """Test path with dots in intermediate directory names."""
        path = Path("src/test/java/com/example.v2/MyTest.java")
        codeflash_output = _build_test_filter([path]); result = codeflash_output # 8.16μs -> 8.68μs (5.89% slower)

    def test_single_element_tuple(self):
        """Test tuple with single element."""
        codeflash_output = _build_test_filter(("com.example.Test",)); result = codeflash_output # 2.56μs -> 2.54μs (0.393% faster)

class TestBuildTestFilterLargeScale:
    """Large scale test cases for _build_test_filter function."""

    def test_large_list_of_strings(self):
        """Test with 100 string class names."""
        test_classes = [f"com.example.Test{i}" for i in range(100)]
        codeflash_output = _build_test_filter(test_classes); result = codeflash_output # 11.7μs -> 12.1μs (2.83% slower)

    def test_large_list_of_paths(self):
        """Test with 100 Path objects."""
        paths = [Path(f"src/test/java/com/example/Test{i}.java") for i in range(100)]
        codeflash_output = _build_test_filter(paths); result = codeflash_output # 178μs -> 181μs (1.77% slower)
        filters = result.split(",")

    def test_large_testfiles_object_behavior_mode(self):
        """Test TestFiles object with 100 test files in behavior mode."""
        mock_test_files_list = []
        for i in range(100):
            mock_test_file = Mock()
            mock_test_file.instrumented_behavior_file_path = Path(f"src/test/java/com/example/Test{i}.java")
            mock_test_file.original_file_path = Path(f"src/test/java/com/example/Test{i}.java")
            mock_test_files_list.append(mock_test_file)

        mock_test_files = Mock()
        mock_test_files.test_files = mock_test_files_list

        codeflash_output = _build_test_filter(mock_test_files, mode="behavior"); result = codeflash_output # 219μs -> 222μs (1.54% slower)
        filters = result.split(",")

    def test_large_testfiles_object_performance_mode(self):
        """Test TestFiles object with 100 test files in performance mode."""
        mock_test_files_list = []
        for i in range(100):
            mock_test_file = Mock()
            mock_test_file.benchmarking_file_path = Path(f"src/test/java/com/example/Benchmark{i}.java")
            mock_test_file.original_file_path = Path(f"src/test/java/com/example/Benchmark{i}.java")
            mock_test_files_list.append(mock_test_file)

        mock_test_files = Mock()
        mock_test_files.test_files = mock_test_files_list

        codeflash_output = _build_test_filter(mock_test_files, mode="performance"); result = codeflash_output # 216μs -> 227μs (4.71% slower)
        filters = result.split(",")

    def test_large_testfiles_with_partial_invalid_paths(self):
        """Test TestFiles with 100 files where 20 have invalid paths."""
        mock_test_files_list = []
        for i in range(100):
            mock_test_file = Mock()
            # Every 5th file has no valid path
            if i % 5 == 0:
                mock_test_file.instrumented_behavior_file_path = None
            else:
                mock_test_file.instrumented_behavior_file_path = Path(f"src/test/java/com/example/Test{i}.java")
            mock_test_file.original_file_path = Path(f"src/test/java/com/example/Test{i}.java")
            mock_test_files_list.append(mock_test_file)

        mock_test_files = Mock()
        mock_test_files.test_files = mock_test_files_list

        codeflash_output = _build_test_filter(mock_test_files, mode="behavior"); result = codeflash_output # 12.6ms -> 216μs (5720% faster)
        filters = result.split(",") if result else []

    def test_deeply_nested_package_structure_large(self):
        """Test with large number of deeply nested package structures."""
        paths = [
            Path(f"src/test/java/com/example/module{i//10}/submodule{i%10}/Test{i}.java")
            for i in range(50)
        ]
        codeflash_output = _build_test_filter(paths); result = codeflash_output # 94.5μs -> 96.0μs (1.52% slower)
        filters = result.split(",")

    def test_mixed_valid_invalid_paths_large_scale(self):
        """Test large list with mixed valid and invalid Path objects."""
        items = []
        for i in range(50):
            # Alternate between valid .java files and invalid .txt files
            if i % 2 == 0:
                items.append(Path(f"src/test/java/com/example/Test{i}.java"))
            else:
                items.append(Path(f"src/test/resources/Data{i}.txt"))

        codeflash_output = _build_test_filter(items); result = codeflash_output # 94.5μs -> 94.9μs (0.402% slower)
        filters = result.split(",") if result else []

    def test_list_with_many_duplicate_strings(self):
        """Test list with many duplicate class names."""
        test_classes = ["com.example.Test1"] * 50 + ["com.example.Test2"] * 50
        codeflash_output = _build_test_filter(test_classes); result = codeflash_output # 12.0μs -> 12.4μs (2.76% slower)
        filters = result.split(",")

    def test_long_package_names(self):
        """Test with very long package names."""
        long_package = ".".join(["com", "example"] + [f"subpkg{i}" for i in range(20)] + ["TestClass"])
        codeflash_output = _build_test_filter([long_package]); result = codeflash_output # 2.28μs -> 2.35μs (2.97% slower)

    def test_performance_mode_with_all_files_missing_benchmarking_path(self):
        """Test performance mode where all files lack benchmarking_file_path."""
        mock_test_files_list = []
        for i in range(50):
            mock_test_file = Mock()
            mock_test_file.benchmarking_file_path = None
            mock_test_file.original_file_path = Path(f"src/test/java/com/example/Test{i}.java")
            mock_test_files_list.append(mock_test_file)

        mock_test_files = Mock()
        mock_test_files.test_files = mock_test_files_list

        codeflash_output = _build_test_filter(mock_test_files, mode="performance"); result = codeflash_output # 30.3ms -> 30.8ms (1.67% slower)

class TestPathToClassNameFunction:
    """Direct tests for the _path_to_class_name helper function."""

    def test_standard_maven_test_path(self):
        """Test standard Maven test directory structure."""
        path = Path("src/test/java/com/example/TestClass.java")
        result = _path_to_class_name(path)

    def test_standard_maven_main_path(self):
        """Test standard Maven main directory structure."""
        path = Path("src/main/java/com/example/MyClass.java")
        result = _path_to_class_name(path)

    def test_non_java_file(self):
        """Test that non-.java files return None."""
        path = Path("src/test/resources/TestData.txt")
        result = _path_to_class_name(path)

    def test_java_file_without_standard_structure(self):
        """Test .java file without standard Maven structure."""
        path = Path("somewhere/MyClass.java")
        result = _path_to_class_name(path)

    def test_deeply_nested_package(self):
        """Test deeply nested package structure."""
        path = Path("src/test/java/org/springframework/boot/test/MyTest.java")
        result = _path_to_class_name(path)

    def test_single_level_package(self):
        """Test single level package."""
        path = Path("src/test/java/myapp/MyTest.java")
        result = _path_to_class_name(path)
# 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-pr1345-2026-02-04T00.36.33 and push.

[KRRT7]

Closing stale bot PR.