⚡️ Speed up function _get_empty_result by 142% in PR #1774 (feat/gradle-executor-from-java)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1774

If you approve this dependent PR, these changes will be merged into the original PR branch feat/gradle-executor-from-java.

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

---

📄 142% (1.42x) speedup for _get_empty_result in codeflash/languages/java/test_runner.py

⏱️ Runtime : 19.6 milliseconds → 8.10 milliseconds (best of 9 runs)

📝 Explanation and details

The optimization eliminated repeated disk writes and expensive UUID generation by creating a single cached empty JUnit XML template file (_EMPTY_JUNIT_TEMPLATE) and reusing it via hard links (falling back to copy if unsupported), replacing per-call template writes with a one-time creation. Additionally, uuid.uuid4() was replaced with a lightweight itertools.count() counter for unique filenames, and tempfile.gettempdir() was cached at module level to avoid repeated lookups. Line profiler confirms the original _write_empty_junit_xml call consumed 64% of _get_combined_junit_xml runtime; the new approach amortizes that cost across all calls, cutting total function time by ~93% (26.2ms → 1.7ms) and delivering a 142% overall speedup.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import subprocess
import tempfile
from pathlib import Path
from unittest.mock import Mock

# imports
import pytest
# function to test
from codeflash.languages.java.test_runner import _get_empty_result

class TestGetEmptyResult:
    """Test suite for _get_empty_result function."""

    # Basic tests — Verify fundamental functionality under normal conditions

    def test_basic_functionality_with_valid_strategy(self):
        """Test that _get_empty_result returns a tuple with correct structure."""
        # Create a mock strategy with the required method
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        # Call the function
        result_xml_path, completed_process = _get_empty_result(strategy, build_root, None)
        
        # Verify the return types
        assert isinstance(result_xml_path, Path)
        assert isinstance(completed_process, subprocess.CompletedProcess)

    def test_empty_result_has_correct_returncode(self):
        """Test that the returned CompletedProcess has returncode -1."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        _, completed_process = _get_empty_result(strategy, build_root, None)
        
        # Verify returncode is -1 to indicate no tests were run
        assert completed_process.returncode == -1

    def test_empty_result_has_correct_args(self):
        """Test that the returned CompletedProcess has expected args."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        _, completed_process = _get_empty_result(strategy, build_root, None)
        
        # Verify the args field indicates a JUnit launcher
        assert isinstance(completed_process.args, list)
        assert "ConsoleLauncher" in completed_process.args

    def test_empty_result_has_empty_stdout(self):
        """Test that the returned CompletedProcess has empty stdout."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        _, completed_process = _get_empty_result(strategy, build_root, None)
        
        # Verify stdout is empty string
        assert completed_process.stdout == ""

    def test_empty_result_has_error_message_in_stderr(self):
        """Test that the returned CompletedProcess has 'No test classes found' in stderr."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        _, completed_process = _get_empty_result(strategy, build_root, None)
        
        # Verify stderr contains the expected error message
        assert "No test classes found" in completed_process.stderr

    def test_strategy_get_reports_dir_called_with_correct_args(self):
        """Test that strategy.get_reports_dir is called with correct arguments."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        test_module = "com.example.tests"
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        _get_empty_result(strategy, build_root, test_module)
        
        # Verify the strategy method was called with the right args
        strategy.get_reports_dir.assert_called_once_with(build_root, test_module)

    def test_with_none_test_module(self):
        """Test that function works correctly when test_module is None."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        result_xml_path, completed_process = _get_empty_result(strategy, build_root, None)
        
        # Verify both return values are valid
        assert isinstance(result_xml_path, Path)
        assert completed_process.returncode == -1

    def test_with_string_test_module(self):
        """Test that function works correctly when test_module is a string."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        test_module = "com.example.tests"
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        result_xml_path, completed_process = _get_empty_result(strategy, build_root, test_module)
        
        # Verify both return values are valid
        assert isinstance(result_xml_path, Path)
        assert completed_process.returncode == -1

    def test_result_xml_path_is_valid_path(self):
        """Test that the returned XML path is in the temp directory."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        result_xml_path, _ = _get_empty_result(strategy, build_root, None) # 132μs -> 95.0μs (39.3% faster)
        
        # Verify the path is in temp directory
        assert str(result_xml_path).startswith(tempfile.gettempdir())

    # Edge tests — Evaluate behavior under extreme or unusual conditions

    def test_with_nonexistent_build_root(self):
        """Test that function works with a non-existent build root path."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir()) / "nonexistent_build_dir_12345"
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        result_xml_path, completed_process = _get_empty_result(strategy, build_root, None) # 132μs -> 69.0μs (91.3% faster)
        
        # Verify it still returns valid structures
        assert isinstance(result_xml_path, Path)
        assert completed_process.returncode == -1

    def test_with_deeply_nested_build_root(self):
        """Test that function works with deeply nested path."""
        strategy = Mock()
        deep_path = Path(tempfile.gettempdir()) / "a" / "b" / "c" / "d" / "e" / "f"
        strategy.get_reports_dir.return_value = deep_path / "reports"
        
        result_xml_path, completed_process = _get_empty_result(strategy, deep_path, None) # 132μs -> 65.5μs (102% faster)
        
        # Verify it returns valid structures
        assert isinstance(result_xml_path, Path)
        assert completed_process.returncode == -1

    def test_with_special_characters_in_test_module(self):
        """Test that function works with special characters in test_module name."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        test_module = "com.example.tests-with_special.chars$123"
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        result_xml_path, completed_process = _get_empty_result(strategy, build_root, test_module) # 132μs -> 66.6μs (98.6% faster)
        
        # Verify it still works correctly
        assert isinstance(result_xml_path, Path)
        assert completed_process.returncode == -1

    def test_return_tuple_length(self):
        """Test that the return value is a tuple of exactly 2 elements."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        result = _get_empty_result(strategy, build_root, None) # 132μs -> 83.6μs (58.3% faster)
        
        # Verify it's a tuple with exactly 2 elements
        assert isinstance(result, tuple)
        assert len(result) == 2

    def test_completed_process_has_java_cp_in_args(self):
        """Test that completed process args contain expected Java command structure."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        _, completed_process = _get_empty_result(strategy, build_root, None) # 133μs -> 63.7μs (109% faster)
        
        # Verify the args structure looks like a Java command
        assert "java" in completed_process.args
        assert "-cp" in completed_process.args

    def test_with_empty_string_test_module(self):
        """Test that function works when test_module is an empty string."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        result_xml_path, completed_process = _get_empty_result(strategy, build_root, "") # 133μs -> 63.7μs (109% faster)
        
        # Verify it still returns valid structures
        assert isinstance(result_xml_path, Path)
        assert completed_process.returncode == -1

    def test_xml_path_file_extension(self):
        """Test that the returned XML path has .xml extension."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        result_xml_path, _ = _get_empty_result(strategy, build_root, None) # 132μs -> 65.5μs (102% faster)
        
        # Verify the path ends with .xml
        assert result_xml_path.suffix == ".xml"

    # Large-scale tests — Assess performance and scalability

    def test_with_multiple_sequential_calls(self):
        """Test that function can be called multiple times successfully."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        # Call the function 100 times
        results = []
        for i in range(100):
            result_xml_path, completed_process = _get_empty_result(strategy, build_root, f"test.module.{i}") # 11.3ms -> 4.59ms (147% faster)
            results.append((result_xml_path, completed_process))
        
        # Verify all results are valid
        assert len(results) == 100
        for result_xml_path, completed_process in results:
            assert isinstance(result_xml_path, Path)
            assert completed_process.returncode == -1

    def test_with_many_different_build_roots(self):
        """Test that function works with many different build root paths."""
        # Create results with 50 different build root paths
        results = []
        for i in range(50):
            strategy = Mock()
            build_root = Path(tempfile.gettempdir()) / f"build_root_{i}"
            strategy.get_reports_dir.return_value = build_root / "reports"
            
            result_xml_path, completed_process = _get_empty_result(strategy, build_root, None) # 5.85ms -> 2.79ms (110% faster)
            results.append((result_xml_path, completed_process))
        
        # Verify all results are valid and different
        assert len(results) == 50
        xml_paths = [r[0] for r in results]
        # Check that not all paths are the same (accounting for randomness in UUID)
        unique_paths = set(str(p) for p in xml_paths)
        # Each should generate a unique path due to uuid in _get_combined_junit_xml
        assert len(unique_paths) == 50

    def test_with_long_module_names(self):
        """Test that function handles very long test module names."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        # Create a very long module name
        long_module = "com." + ".".join([f"module{i}" for i in range(100)])
        
        result_xml_path, completed_process = _get_empty_result(strategy, build_root, long_module) # 132μs -> 83.6μs (58.8% faster)
        
        # Verify it still works
        assert isinstance(result_xml_path, Path)
        assert completed_process.returncode == -1

    def test_completed_process_attributes_are_immutable(self):
        """Test that the returned CompletedProcess has expected immutable structure."""
        strategy = Mock()
        build_root = Path(tempfile.gettempdir())
        strategy.get_reports_dir.return_value = build_root / "reports"
        
        _, completed_process = _get_empty_result(strategy, build_root, None) # 133μs -> 62.8μs (113% faster)
        
        # Verify all expected attributes are present and have correct types
        assert hasattr(completed_process, "args")
        assert hasattr(completed_process, "returncode")
        assert hasattr(completed_process, "stdout")
        assert hasattr(completed_process, "stderr")
        assert isinstance(completed_process.args, list)
        assert isinstance(completed_process.returncode, int)
        assert isinstance(completed_process.stdout, str)
        assert isinstance(completed_process.stderr, str)

To edit these changes git checkout codeflash/optimize-pr1774-2026-03-09T23.46.48 and push.

[claude]

Claude finished @codeflash-ai[bot]'s task in 2m 44s —— View job

---

PR Review Summary

• Triage: classify PR scope — production code change in codeflash/languages/java/test_runner.py
• Lint and type checks — auto-fixed 2 issues, pushed commit
• Resolve stale review threads — none found
• Code review
• Duplicate detection
• Test coverage

---

Prek Checks

Auto-fixed and committed:

• F401: Removed now-unused import uuid (no longer needed after replacing with itertools.count)
• ruff-format: Removed an extra blank line in _get_combined_junit_xml

Running uv run prek run --from-ref origin/feat/gradle-executor-from-java now passes cleanly. ✅

---

Code Review

The optimization is clever and the benchmark numbers are credible. A few concerns:

1. Counter-based ID loses cross-process uniqueness (medium risk)

itertools.count() is per-process. If codeflash runs multiple worker processes simultaneously (which worktree mode does), two processes could both produce codeflash_java_results_-1_1.xml, silently overwriting each other's files. The original uuid.uuid4().hex[:8] was cross-process unique. Consider combining the counter with the process ID to restore safety:

_PID = os.getpid()
result_xml_path = _TMPDIR / f"codeflash_java_results_{candidate_index}_{_PID}_{result_id}.xml"

Fix this →

2. Bare except Exception on os.link (low risk)

os.link can only fail with OSError (cross-device, unsupported FS, etc.). Catching all Exception types hides bugs (e.g., a PermissionError on result_xml_path is a real problem that should surface):

except OSError:
    shutil.copyfile(_EMPTY_JUNIT_TEMPLATE, result_xml_path)

Fix this →

3. Duplicated template-creation block (low risk)

The if not _EMPTY_JUNIT_TEMPLATE.exists(): _write_empty_junit_xml(...) block appears twice (lines ~931-935 and ~947-950). This could be extracted into a one-liner helper _ensure_empty_template() to keep the code DRY.

4. Hard links share inode — downstream write would corrupt the template

If any caller ever writes to the returned result_xml_path, it would silently mutate _EMPTY_JUNIT_TEMPLATE too, corrupting all future empty results. Currently parse_test_results only reads the file's parent directory, not the file itself, so this is safe — but it is a fragile invariant. Worth a comment noting this assumption.

---

Duplicate Detection

No duplicates detected. The _get_combined_junit_xml/_get_empty_result functions are Java-specific and have no equivalent in the Python or JavaScript language modules.

---

Test Coverage

No existing unit tests cover _get_combined_junit_xml or the new module-level constants (_result_counter, _EMPTY_JUNIT_TEMPLATE). The PR's 168 generated regression tests cover _get_empty_result at 100% as reported. No coverage regression introduced.

---

Last updated: 2026-03-09T23:48Z
| Branch