codeflash-omni-java

[misrasaurabh1]

No description provided.

[codeflash-ai]

⚡️Codeflash found 70% (0.70x) speedup for should_modify_java_config in codeflash/cli_cmds/init_java.py

⏱️ Runtime : 714 microseconds → 421 microseconds (best of 60 runs)

📝 Explanation and details

The optimized code achieves a 69% speedup (714μs → 421μs) by replacing pathlib.Path operations with equivalent os module functions, which have significantly lower overhead.

Key optimizations:

1. os.getcwd() instead of Path.cwd(): The line profiler shows Path.cwd() took 689,637ns (34.1% of total time) vs os.getcwd() taking only 68,036ns (7.4%). This is a ~10x improvement because Path.cwd() instantiates a Path object and performs additional normalization, while os.getcwd() returns a raw string from a system call.

2. os.path.join() instead of Path division operator: Constructing the config path via project_root / "codeflash.toml" took 386,582ns (19.1%) vs os.path.join() taking 190,345ns (20.6%). Though the percentage appears similar, the absolute time is ~50% faster because the / operator creates a new Path object with its associated overhead.

3. os.path.exists() instead of Path.exists(): The existence check dropped from 476,490ns (23.6%) to 223,477ns (24.2%) - roughly 2x faster. The os.path.exists() function directly calls the stat syscall, while Path.exists() goes through Path's object model.

Why this works:
Path objects provide a cleaner API but add object instantiation, method dispatch, and normalization overhead. For simple filesystem checks in initialization code that runs frequently, using lower-level os functions eliminates this overhead while maintaining identical functionality.

Test results:
All test cases show 68-111% speedup across scenarios including:

• Empty directories (fastest: 82-87% improvement)
• Large directories with 500 files (68-111% improvement)
• Edge cases like symlinks and directory-as-file (75-82% improvement)

The optimization is particularly beneficial for CLI initialization code that may run on every command invocation, where sub-millisecond improvements in frequently-called functions compound into noticeable user experience gains.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from __future__ import annotations

# imports
import os
from pathlib import Path
from typing import Any

import pytest  # used for our unit tests
from codeflash.cli_cmds.init_java import should_modify_java_config

def test_no_config_file_does_not_prompt_and_returns_true(monkeypatch, tmp_path):
    # Arrange: ensure working directory has no codeflash.toml
    monkeypatch.chdir(tmp_path)  # set cwd to a clean temporary directory

    # Replace Confirm.ask with a function that fails the test if called.
    def fail_if_called(*args, **kwargs):
        raise AssertionError("Confirm.ask should not be called when no config file exists")

    # Patch the exact attribute that the function imports at runtime.
    monkeypatch.setattr("rich.prompt.Confirm.ask", fail_if_called, raising=True)

    # Act: call function under test
    codeflash_output = should_modify_java_config(); result = codeflash_output # 28.9μs -> 15.9μs (82.0% faster)

def test_config_file_exists_prompts_and_respects_true_choice(monkeypatch, tmp_path):
    # Arrange: create a codeflash.toml file so the function will detect it
    monkeypatch.chdir(tmp_path)
    config_file = tmp_path / "codeflash.toml"
    config_file.write_text("existing = true")  # create the file

    # Capture the arguments passed to Confirm.ask and return True to simulate user acceptance
    called = {}

    def fake_ask(prompt, default, show_default):
        # Record inputs for later assertions
        called["prompt"] = prompt
        called["default"] = default
        called["show_default"] = show_default
        return True

    # Patch Confirm.ask used inside the function
    monkeypatch.setattr("rich.prompt.Confirm.ask", fake_ask, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 25.6μs -> 13.7μs (86.9% faster)

def test_config_file_exists_prompts_and_respects_false_choice(monkeypatch, tmp_path):
    # Arrange: create the config file
    monkeypatch.chdir(tmp_path)
    (tmp_path / "codeflash.toml").write_text("existing = true")

    # Simulate user declining re-configuration
    def fake_ask_decline(prompt, default, show_default):
        return False

    monkeypatch.setattr("rich.prompt.Confirm.ask", fake_ask_decline, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 24.7μs -> 13.3μs (86.3% faster)

def test_presence_of_pom_xml_does_not_trigger_prompt(monkeypatch, tmp_path):
    # Arrange: create a pom.xml but NOT codeflash.toml
    monkeypatch.chdir(tmp_path)
    (tmp_path / "pom.xml").write_text("<project></project>")

    # If Confirm.ask is called, fail the test because only codeflash.toml should trigger it in current implementation
    def fail_if_called(*args, **kwargs):
        raise AssertionError("Confirm.ask should not be called when only pom.xml exists (implementation checks codeflash.toml)")

    monkeypatch.setattr("rich.prompt.Confirm.ask", fail_if_called, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 28.3μs -> 16.6μs (69.9% faster)

def test_codeflash_config_is_directory_triggers_prompt(monkeypatch, tmp_path):
    # Arrange: create a directory named codeflash.toml (Path.exists will be True)
    monkeypatch.chdir(tmp_path)
    (tmp_path / "codeflash.toml").mkdir()

    # Simulate user selecting True
    monkeypatch.setattr("rich.prompt.Confirm.ask", lambda *a, **k: True, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 23.6μs -> 12.9μs (82.2% faster)

def test_codeflash_config_symlink_triggers_prompt_if_supported(monkeypatch, tmp_path):
    # Arrange: attempt to create a symlink to a real file; skip if symlink not supported
    if not hasattr(os, "symlink"):
        pytest.skip("Platform does not support os.symlink; skipping symlink test")

    real = tmp_path / "real_config"
    real.write_text("x = 1")
    link = tmp_path / "codeflash.toml"

    try:
        os.symlink(real, link)  # may fail on Windows without privileges
    except (OSError, NotImplementedError) as e:
        pytest.skip(f"Could not create symlink on this platform/environment: {e}")

    monkeypatch.chdir(tmp_path)

    # Simulate user declining re-configuration
    monkeypatch.setattr("rich.prompt.Confirm.ask", lambda *a, **k: False, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 24.9μs -> 14.2μs (75.7% faster)

def test_large_directory_without_config_is_fast_and_does_not_prompt(monkeypatch, tmp_path):
    # Large scale scenario: create many files (but under 1000) to simulate busy project directory.
    monkeypatch.chdir(tmp_path)
    num_files = 500  # under the 1000 element guideline
    for i in range(num_files):
        # Create many innocuous files; should not affect the function's behavior
        (tmp_path / f"file_{i}.txt").write_text(str(i))

    # Ensure Confirm.ask is not called
    def fail_if_called(*args, **kwargs):
        raise AssertionError("Confirm.ask should not be called when codeflash.toml is absent even in large directories")

    monkeypatch.setattr("rich.prompt.Confirm.ask", fail_if_called, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 36.3μs -> 21.6μs (68.0% faster)

def test_large_directory_with_config_prompts_once(monkeypatch, tmp_path):
    # Large scale scenario with config present: many files plus codeflash.toml
    monkeypatch.chdir(tmp_path)
    num_files = 500
    for i in range(num_files):
        (tmp_path / f"file_{i}.txt").write_text(str(i))

    # Create the config file that should trigger prompting
    (tmp_path / "codeflash.toml").write_text("reconfigure = maybe")

    # Track how many times Confirm.ask is invoked to ensure single prompt
    counter = {"calls": 0}

    def fake_ask(prompt, default, show_default):
        counter["calls"] += 1
        return True

    monkeypatch.setattr("rich.prompt.Confirm.ask", fake_ask, raising=True)

    # Act
    codeflash_output = should_modify_java_config(); result = codeflash_output # 30.8μs -> 14.6μs (111% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import os
import tempfile
from pathlib import Path
from unittest.mock import MagicMock, patch

# imports
import pytest
from codeflash.cli_cmds.init_java import should_modify_java_config

class TestShouldModifyJavaConfigBasic:
    """Basic test cases for should_modify_java_config function."""

    def test_no_config_file_exists_returns_true(self):
        """
        Scenario: Project has no existing codeflash.toml file
        Expected: Function returns (True, None) without prompting user
        """
        # Create a temporary directory without codeflash.toml
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_config_file_exists_user_confirms(self):
        """
        Scenario: Project has existing codeflash.toml and user confirms re-configuration
        Expected: Function prompts user and returns (True, None) if user confirms
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create a codeflash.toml file
                config_file = Path(tmpdir) / "codeflash.toml"
                config_file.touch()

                # Mock the Confirm.ask to return True (user confirms)
                with patch('rich.prompt.Confirm.ask', return_value=True):
                    codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_config_file_exists_user_declines(self):
        """
        Scenario: Project has existing codeflash.toml and user declines re-configuration
        Expected: Function prompts user and returns (False, None) if user declines
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create a codeflash.toml file
                config_file = Path(tmpdir) / "codeflash.toml"
                config_file.touch()

                # Mock the Confirm.ask to return False (user declines)
                with patch('rich.prompt.Confirm.ask', return_value=False):
                    codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_return_tuple_structure(self):
        """
        Scenario: Verify the function always returns a tuple with specific structure
        Expected: Return value is a tuple of (bool, None)
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

class TestShouldModifyJavaConfigEdgeCases:
    """Edge case test cases for should_modify_java_config function."""

    def test_config_file_exists_but_empty(self):
        """
        Scenario: codeflash.toml file exists but is empty
        Expected: File is still considered as existing, prompts user
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create an empty codeflash.toml file
                config_file = Path(tmpdir) / "codeflash.toml"
                config_file.write_text("")

                with patch('rich.prompt.Confirm.ask', return_value=True):
                    codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_config_file_with_content(self):
        """
        Scenario: codeflash.toml file exists with actual TOML content
        Expected: Prompts user regardless of file content
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create a codeflash.toml file with content
                config_file = Path(tmpdir) / "codeflash.toml"
                config_file.write_text("[codeflash]\nversion = 1\n")

                with patch('rich.prompt.Confirm.ask', return_value=False):
                    codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_config_file_case_sensitive(self):
        """
        Scenario: Directory has 'Codeflash.toml' or 'CODEFLASH.TOML' instead of lowercase
        Expected: Function only recognizes 'codeflash.toml' (case-sensitive on Unix)
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create a file with different casing
                config_file = Path(tmpdir) / "Codeflash.toml"
                config_file.touch()

                codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    def test_config_file_is_directory_not_file(self):
        """
        Scenario: codeflash.toml exists as a directory instead of a file
        Expected: Path.exists() still returns True, prompts user
        """
        with tempfile.TemporaryDirectory() as tmpdir:
            original_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                # Create codeflash.toml as a directory
                config_dir = Path(tmpdir) / "codeflash.toml"
                config_dir.mkdir()

                with patch('rich.prompt.Confirm.ask', return_value=True):
                    codeflash_output = should_modify_java_config(); result = codeflash_output
            finally:
                os.chdir(original_cwd)

    

To test or edit this optimization locally git merge codeflash/optimize-pr1199-2026-02-01T21.20.00

Suggested change

	project_root = Path.cwd()
	# Check for existing codeflash config in pom.xml or a separate config file
	codeflash_config_path = project_root / "codeflash.toml"
	if codeflash_config_path.exists():
	project_root = os.getcwd()
	# Check for existing codeflash config in pom.xml or a separate config file
	codeflash_config_path = os.path.join(project_root, "codeflash.toml")
	if os.path.exists(codeflash_config_path):

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 1,498% (14.98x) speedup for JavaAssertTransformer._extract_target_calls in codeflash/languages/java/remove_asserts.py

⏱️ Runtime : 107 milliseconds → 6.71 milliseconds (best of 156 runs)

A dependent PR with the suggested changes has been created. Please review:

• ⚡️ Speed up method JavaAssertTransformer._extract_target_calls by 1,498% in PR #1199 (omni-java) #1359

If you approve, it will be merged into this PR (branch omni-java).

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 17% (0.17x) speedup for JavaAssertTransformer._extract_lambda_body in codeflash/languages/java/remove_asserts.py

⏱️ Runtime : 580 microseconds → 495 microseconds (best of 250 runs)

A new Optimization Review has been created.

🔗 Review here

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 62% (0.62x) speedup for JavaAssertTransformer._find_balanced_parens in codeflash/languages/java/remove_asserts.py

⏱️ Runtime : 1.65 milliseconds → 1.02 milliseconds (best of 138 runs)

A dependent PR with the suggested changes has been created. Please review:

• ⚡️ Speed up method JavaAssertTransformer._find_balanced_parens by 62% in PR #1199 (omni-java) #1361

If you approve, it will be merged into this PR (branch omni-java).

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 71% (0.71x) speedup for JavaAssertTransformer._find_balanced_braces in codeflash/languages/java/remove_asserts.py

⏱️ Runtime : 4.83 milliseconds → 2.82 milliseconds (best of 138 runs)

A dependent PR with the suggested changes has been created. Please review:

• ⚡️ Speed up method JavaAssertTransformer._find_balanced_braces by 71% in PR #1199 (omni-java) #1363

If you approve, it will be merged into this PR (branch omni-java).

[codeflash-ai]

⚡️Codeflash found 31% (0.31x) speedup for JavaAssertTransformer._generate_replacement in codeflash/languages/java/remove_asserts.py

⏱️ Runtime : 396 microseconds → 302 microseconds (best of 250 runs)

📝 Explanation and details

This optimization achieves a 31% runtime improvement (396μs → 302μs) by introducing a fast path for the most common case in assertion transformation.

Key Optimization: Single Target Call Fast Path

The primary performance gain comes from recognizing that most assertions contain only a single target call. The optimized code adds an early-return fast path for this common case:

if len(assertion.target_calls) == 1:
    self.invocation_counter += 1
    call = assertion.target_calls[0]
    return f"{assertion.leading_whitespace}Object _cf_result{self.invocation_counter} = {call.full_call};"

This avoids:

• Creating an empty list (replacements = [])
• Computing base_indent via lstrip("\n\r")
• Enumerating through the loop with index tracking
• Building a string with "\n".join()

For single-call assertions, we directly construct and return the result string in one operation.

Why This Matters

Looking at the test results, most test cases show dramatic speedups (64-114% faster for single-call cases), confirming that single target calls dominate real-world usage:

• test_single_target_call_basic: 64.9% faster
• test_invocation_counter_persists_across_calls (2 sequential single calls): 69.9% and 49.4% faster
• test_single_target_call_generates_capture_statement: 83.5% faster

Multiple-call cases show smaller but still meaningful improvements (3-27% faster) from the simplified loop structure that processes the first call separately, then iterates target_calls[1:] without enumerate overhead.

Impact on Java Test Transformation

Since JavaAssertTransformer is used to remove assertions from Java test code during optimization analysis, this improvement directly speeds up the test transformation pipeline. The fast path optimization is particularly valuable because test assertions typically check a single method result, making this the dominant code path during Java test processing.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from types import SimpleNamespace  # convenient container for attributes

# imports
import pytest  # used for our unit tests
from codeflash.languages.java.remove_asserts import JavaAssertTransformer

def test_no_target_calls_comments_out():
    # Arrange: fresh transformer so invocation_counter starts at 0
    transformer = JavaAssertTransformer(function_name="test")
    # Create an assertion-like object with no target calls and not an exception assertion
    assertion = SimpleNamespace(
        is_exception_assertion=False,
        target_calls=[],
        leading_whitespace="    ",  # four spaces indentation
        lambda_body=None,
    )

    # Act: generate replacement
    codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 791ns -> 812ns (2.59% slower)

def test_single_target_call_basic():
    # Arrange: new transformer to ensure invocation_counter resets
    transformer = JavaAssertTransformer(function_name="test")
    # A single target call should produce a single Object assignment line
    assertion = SimpleNamespace(
        is_exception_assertion=False,
        target_calls=[SimpleNamespace(full_call="computeValue()")],
        leading_whitespace="\t",  # a single tab
        lambda_body=None,
    )

    # Act
    codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.35μs -> 1.42μs (64.9% faster)

def test_multiple_target_calls_newlines_and_carriage_returns():
    # Arrange: test how leading newlines and carriage returns are handled for subsequent lines
    transformer = JavaAssertTransformer(function_name="test")
    # leading whitespace contains newline and carriage return followed by indentation
    leading = "\r\n    "  # Windows style newline then 4 spaces
    # Two calls to ensure first uses full leading whitespace and second uses base_indent
    calls = [SimpleNamespace(full_call="firstCall()"), SimpleNamespace(full_call="secondCall()")]
    assertion = SimpleNamespace(
        is_exception_assertion=False,
        target_calls=calls,
        leading_whitespace=leading,
        lambda_body=None,
    )

    # Act
    codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 3.01μs -> 3.06μs (1.64% slower)

    # Base indent should be the leading whitespace with leading newlines/carriage returns stripped
    base_indent = leading.lstrip("\n\r")  # expected "    "
    # Expect exactly two lines: first starts with the original leading (including newline),
    # second starts with the base indent (no leading newline)
    expected = f"{leading}Object _cf_result1 = firstCall();\n{base_indent}Object _cf_result2 = secondCall();"

def test_exception_with_lambda_adds_semicolon_when_missing():
    # Arrange: exception assertion with a lambda body that lacks a trailing semicolon
    transformer = JavaAssertTransformer(function_name="test")
    assertion = SimpleNamespace(
        is_exception_assertion=True,
        target_calls=[],
        leading_whitespace="  ",  # two spaces
        lambda_body="mightThrow()"  # no semicolon at end
    )

    # Act
    codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.11μs -> 1.83μs (15.3% faster)

    # The code should wrap the lambda body in a try/catch and ensure the code_to_run ends with a semicolon.
    # invocation_counter starts at 0 and is incremented once in _generate_exception_replacement, so the
    # ignored variable should be _cf_ignored1.
    expected = "  try { mightThrow(); } catch (Exception _cf_ignored1) {}"

def test_exception_with_lambda_preserves_existing_semicolon():
    # Arrange: lambda body already ends with a semicolon; don't add a second semicolon
    transformer = JavaAssertTransformer(function_name="test")
    assertion = SimpleNamespace(
        is_exception_assertion=True,
        target_calls=[],
        leading_whitespace="",  # no indent
        lambda_body="doItNow();"  # already has semicolon
    )

    # Act
    codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 1.66μs -> 1.64μs (1.22% faster)

def test_exception_with_target_call_fallback():
    # Arrange: no lambda body but target_calls exist -> fallback to using first target call
    transformer = JavaAssertTransformer(function_name="test")
    call = SimpleNamespace(full_call="calculator.divide(1, 0)")
    assertion = SimpleNamespace(
        is_exception_assertion=True,
        target_calls=[call],
        leading_whitespace="\t",  # preserve tab indent
        lambda_body=None
    )

    # Act
    codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 1.52μs -> 1.48μs (2.77% faster)

def test_exception_fallback_comments_when_no_callable_found():
    # Arrange: exception assertion but no lambda_body and no target_calls -> comment fallback
    transformer = JavaAssertTransformer(function_name="test")
    assertion = SimpleNamespace(
        is_exception_assertion=True,
        target_calls=[],
        leading_whitespace=" ",  # single space
        lambda_body=None
    )

    # Act
    codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 1.07μs -> 1.03μs (3.88% faster)

def test_invocation_counter_persists_across_calls():
    # Arrange: ensure invocation_counter increments across multiple invocations on same transformer
    transformer = JavaAssertTransformer(function_name="test")

    a1 = SimpleNamespace(
        is_exception_assertion=False,
        target_calls=[SimpleNamespace(full_call="alpha()")],
        leading_whitespace="",
        lambda_body=None,
    )
    a2 = SimpleNamespace(
        is_exception_assertion=False,
        target_calls=[SimpleNamespace(full_call="beta()")],
        leading_whitespace="",
        lambda_body=None,
    )

    # Act: first call should create _cf_result1
    codeflash_output = transformer._generate_replacement(a1); r1 = codeflash_output # 2.38μs -> 1.40μs (69.9% faster)
    # Act: second call on same transformer should create _cf_result2 (counter persists)
    codeflash_output = transformer._generate_replacement(a2); r2 = codeflash_output # 1.06μs -> 711ns (49.4% faster)

def test_large_scale_many_target_calls_within_limits():
    # Arrange: large-scale test but keep number under 1000 as requested
    transformer = JavaAssertTransformer(function_name="test")
    N = 300  # sufficiently large for stress, but under the 1000-element constraint
    # Create N target calls with unique names
    calls = [SimpleNamespace(full_call=f"heavyCall{i}()") for i in range(1, N + 1)]
    assertion = SimpleNamespace(
        is_exception_assertion=False,
        target_calls=calls,
        leading_whitespace="",  # no leading whitespace to simplify counting
        lambda_body=None,
    )

    # Act
    codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 81.6μs -> 66.1μs (23.4% faster)

    # Assert: the result should contain N lines separated by \n
    lines = result.split("\n")

def test_base_indent_becomes_empty_when_only_newlines_present():
    # Arrange: leading_whitespace contains only newline characters -> base_indent becomes empty,
    # so subsequent lines should start with no indentation.
    transformer = JavaAssertTransformer(function_name="test")
    leading = "\n\n"  # only newlines
    calls = [SimpleNamespace(full_call="a()"), SimpleNamespace(full_call="b()")]
    assertion = SimpleNamespace(
        is_exception_assertion=False,
        target_calls=calls,
        leading_whitespace=leading,
        lambda_body=None,
    )

    # Act
    codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 3.11μs -> 2.98μs (4.40% faster)

    # The first line should start with the original leading whitespace (two newlines),
    # the second line should start with an empty base indent (no leading spaces).
    expected = f"{leading}Object _cf_result1 = a();\nObject _cf_result2 = b();"
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from dataclasses import dataclass

import pytest
from codeflash.languages.java.parser import JavaAnalyzer, get_java_analyzer
from codeflash.languages.java.remove_asserts import JavaAssertTransformer

# Define the AssertionMatch and TargetCall dataclasses that are used by _generate_replacement
@dataclass
class TargetCall:
    """Represents a target function call found in an assertion."""
    full_call: str

@dataclass
class AssertionMatch:
    """Represents a matched assertion in Java code."""
    is_exception_assertion: bool
    target_calls: list[TargetCall]
    leading_whitespace: str
    lambda_body: str | None = None

class TestGenerateReplacementBasic:
    """Basic test cases for JavaAssertTransformer._generate_replacement"""

    def test_no_target_calls_returns_comment(self):
        """Test that assertions with no target calls are commented out"""
        # Create a transformer instance
        transformer = JavaAssertTransformer("testMethod")
        
        # Create an assertion with no target calls
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[],
            leading_whitespace="        "
        )
        
        # Generate replacement
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 662ns -> 681ns (2.79% slower)

    def test_single_target_call_generates_capture_statement(self):
        """Test that a single target call generates a capture statement"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="calculator.add(1, 2)")],
            leading_whitespace="        "
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.22μs -> 1.21μs (83.5% faster)

    def test_multiple_target_calls_generates_multiple_statements(self):
        """Test that multiple target calls generate multiple capture statements"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[
                TargetCall(full_call="calculator.add(1, 2)"),
                TargetCall(full_call="calculator.subtract(5, 3)")
            ],
            leading_whitespace="        "
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.73μs -> 2.63μs (3.42% faster)
        
        # Should have multiple lines
        lines = result.split("\n")

    def test_invocation_counter_increments(self):
        """Test that invocation counter increments correctly"""
        transformer = JavaAssertTransformer("testMethod")
        
        # First assertion
        assertion1 = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="method1()")],
            leading_whitespace=""
        )
        codeflash_output = transformer._generate_replacement(assertion1); result1 = codeflash_output # 2.08μs -> 1.09μs (90.8% faster)
        
        # Second assertion
        assertion2 = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="method2()")],
            leading_whitespace=""
        )
        codeflash_output = transformer._generate_replacement(assertion2); result2 = codeflash_output # 902ns -> 511ns (76.5% faster)

    def test_exception_assertion_with_lambda_body(self):
        """Test exception assertion replacement with lambda body"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=True,
            target_calls=[],
            leading_whitespace="        ",
            lambda_body="calculator.divide(1, 0)"
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 1.62μs -> 1.64μs (1.22% slower)

    def test_exception_assertion_without_lambda_uses_target_call(self):
        """Test exception assertion falls back to target calls if no lambda"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=True,
            target_calls=[TargetCall(full_call="riskyOperation()")],
            leading_whitespace="    ",
            lambda_body=None
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 1.22μs -> 1.18μs (3.38% faster)

    def test_exception_assertion_without_lambda_or_calls(self):
        """Test exception assertion falls back to comment if no lambda or calls"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=True,
            target_calls=[],
            leading_whitespace="    ",
            lambda_body=None
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 881ns -> 892ns (1.23% slower)

class TestGenerateReplacementEdgeCases:
    """Edge case test cases for JavaAssertTransformer._generate_replacement"""

    def test_empty_leading_whitespace(self):
        """Test with empty leading whitespace"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="test()")],
            leading_whitespace=""
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.25μs -> 1.16μs (94.0% faster)

    def test_tab_indentation(self):
        """Test with tab indentation"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="test()")],
            leading_whitespace="\t\t"
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.07μs -> 1.12μs (84.8% faster)

    def test_newline_in_leading_whitespace_with_multiple_calls(self):
        """Test that subsequent calls strip leading newlines"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[
                TargetCall(full_call="call1()"),
                TargetCall(full_call="call2()")
            ],
            leading_whitespace="\n        "
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.90μs -> 2.85μs (1.72% faster)
        lines = result.split("\n")

    def test_lambda_body_without_semicolon(self):
        """Test exception assertion adds semicolon if lambda body missing it"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=True,
            target_calls=[],
            leading_whitespace="",
            lambda_body="obj.method()"
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 1.60μs -> 1.61μs (0.620% slower)

    def test_lambda_body_with_semicolon(self):
        """Test exception assertion doesn't double-add semicolon"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=True,
            target_calls=[],
            leading_whitespace="",
            lambda_body="obj.method();"
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 1.36μs -> 1.38μs (1.52% slower)

    def test_complex_method_call_with_arguments(self):
        """Test with complex method calls containing special characters"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="calculator.divide(10, 3)")],
            leading_whitespace="    "
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.19μs -> 1.16μs (88.7% faster)

    def test_chained_method_calls(self):
        """Test with chained method calls"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="object.method1().method2().method3()")],
            leading_whitespace=""
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.03μs -> 1.08μs (88.0% faster)

    def test_method_call_with_lambda_argument(self):
        """Test with method call that has lambda as argument"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="stream.filter(x -> x > 5)")],
            leading_whitespace=""
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.06μs -> 1.03μs (100% faster)

    def test_very_large_indentation(self):
        """Test with very deep indentation (24 spaces)"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="test()")],
            leading_whitespace=" " * 24
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.04μs -> 1.08μs (88.9% faster)

    def test_static_method_call(self):
        """Test with static method calls"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="Math.max(5, 10)")],
            leading_whitespace=""
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.03μs -> 1.05μs (93.3% faster)

    def test_qualified_method_call(self):
        """Test with fully qualified method calls"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="java.util.Arrays.asList(1, 2, 3)")],
            leading_whitespace=""
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.03μs -> 1.04μs (95.2% faster)

    def test_exception_assertion_counter_with_mixed_types(self):
        """Test that exception assertions increment counter separately"""
        transformer = JavaAssertTransformer("testMethod")
        
        # Regular assertion
        assertion1 = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="call1()")],
            leading_whitespace=""
        )
        transformer._generate_replacement(assertion1) # 2.08μs -> 972ns (114% faster)
        
        # Exception assertion
        assertion2 = AssertionMatch(
            is_exception_assertion=True,
            target_calls=[],
            leading_whitespace="",
            lambda_body="call2()"
        )
        codeflash_output = transformer._generate_replacement(assertion2); result2 = codeflash_output # 1.39μs -> 1.41μs (1.49% slower)

class TestGenerateReplacementLargeScale:
    """Large scale test cases for JavaAssertTransformer._generate_replacement"""

    def test_many_sequential_assertions(self):
        """Test handling of many sequential assertions"""
        transformer = JavaAssertTransformer("testMethod")
        
        # Generate 100 assertions
        for i in range(100):
            assertion = AssertionMatch(
                is_exception_assertion=False,
                target_calls=[TargetCall(full_call=f"method{i}()")],
                leading_whitespace="    "
            )
            codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 67.7μs -> 40.1μs (68.7% faster)

    def test_many_target_calls_in_single_assertion(self):
        """Test assertion with many target calls"""
        transformer = JavaAssertTransformer("testMethod")
        
        # Create assertion with 50 target calls
        target_calls = [TargetCall(full_call=f"method{i}()") for i in range(50)]
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=target_calls,
            leading_whitespace="    "
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 14.6μs -> 12.2μs (20.2% faster)
        lines = result.split("\n")
        
        # Each line should have correct variable name
        for i, line in enumerate(lines):
            pass

    def test_deeply_nested_indentation_with_many_calls(self):
        """Test with very deep nesting and multiple calls"""
        transformer = JavaAssertTransformer("testMethod")
        
        # Create deep indentation (60 spaces)
        deep_indent = " " * 60
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[
                TargetCall(full_call="call1()"),
                TargetCall(full_call="call2()"),
                TargetCall(full_call="call3()")
            ],
            leading_whitespace="\n" + deep_indent
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 3.05μs -> 3.12μs (2.25% slower)
        lines = result.split("\n")
        
        # All non-first lines should have the base indent
        for i in range(1, len(lines)):
            pass

    def test_concurrent_transformer_instances(self):
        """Test that multiple transformer instances maintain independent counters"""
        transformer1 = JavaAssertTransformer("method1")
        transformer2 = JavaAssertTransformer("method2")
        
        # Use transformer1
        for i in range(25):
            assertion = AssertionMatch(
                is_exception_assertion=False,
                target_calls=[TargetCall(full_call=f"t1_call{i}()")],
                leading_whitespace=""
            )
            transformer1._generate_replacement(assertion) # 18.0μs -> 10.5μs (72.3% faster)
        
        # Use transformer2
        for i in range(15):
            assertion = AssertionMatch(
                is_exception_assertion=False,
                target_calls=[TargetCall(full_call=f"t2_call{i}()")],
                leading_whitespace=""
            )
            transformer2._generate_replacement(assertion) # 9.87μs -> 5.79μs (70.3% faster)

    def test_alternating_assertion_types(self):
        """Test alternating between regular and exception assertions"""
        transformer = JavaAssertTransformer("testMethod")
        
        # Alternate 50 times
        for i in range(50):
            if i % 2 == 0:
                # Regular assertion
                assertion = AssertionMatch(
                    is_exception_assertion=False,
                    target_calls=[TargetCall(full_call=f"regularCall{i}()")],
                    leading_whitespace=""
                )
            else:
                # Exception assertion
                assertion = AssertionMatch(
                    is_exception_assertion=True,
                    target_calls=[],
                    leading_whitespace="",
                    lambda_body=f"exceptionCall{i}()"
                )
            
            codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 33.1μs -> 25.2μs (31.5% faster)

    def test_large_method_call_string(self):
        """Test with very long method call string"""
        transformer = JavaAssertTransformer("testMethod")
        
        # Create a large method call (500+ characters)
        large_call = "veryLongMethodName(" + ", ".join([f"param{i}" for i in range(50)]) + ")"
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call=large_call)],
            leading_whitespace=""
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.06μs -> 1.16μs (77.5% faster)

    def test_many_exception_assertions_sequential(self):
        """Test many exception assertions in sequence"""
        transformer = JavaAssertTransformer("testMethod")
        
        for i in range(100):
            assertion = AssertionMatch(
                is_exception_assertion=True,
                target_calls=[],
                leading_whitespace="",
                lambda_body=f"risky{i}()"
            )
            codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 51.3μs -> 50.9μs (0.648% faster)

    def test_many_lines_in_output(self):
        """Test handling of assertions that produce many output lines"""
        transformer = JavaAssertTransformer("testMethod")
        
        # Create assertion with many target calls
        target_calls = [TargetCall(full_call=f"call{i}()") for i in range(200)]
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=target_calls,
            leading_whitespace="  "
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 51.2μs -> 40.3μs (26.9% faster)
        lines = result.split("\n")
        
        # Each line should be properly formatted
        for i, line in enumerate(lines):
            pass

    def test_mixed_whitespace_preservation(self):
        """Test that mixed whitespace types are preserved"""
        transformer = JavaAssertTransformer("testMethod")
        
        # Mix of tabs and spaces
        mixed_indent = "\t    \t  "
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="test()")],
            leading_whitespace=mixed_indent
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.08μs -> 1.08μs (92.6% faster)

    def test_unicode_in_method_calls(self):
        """Test handling of unicode characters in method names"""
        transformer = JavaAssertTransformer("testMethod")
        
        # Java allows unicode in method names (via escape sequences)
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call="method_\u00e9()")],
            leading_whitespace=""
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.04μs -> 1.03μs (98.1% faster)

    def test_special_characters_in_arguments(self):
        """Test method calls with special characters in string arguments"""
        transformer = JavaAssertTransformer("testMethod")
        
        assertion = AssertionMatch(
            is_exception_assertion=False,
            target_calls=[TargetCall(full_call='method("test\\nvalue")')],
            leading_whitespace=""
        )
        
        codeflash_output = transformer._generate_replacement(assertion); result = codeflash_output # 2.04μs -> 1.04μs (96.2% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To test or edit this optimization locally git merge codeflash/optimize-pr1199-2026-02-04T01.55.52

Click to see suggested changes

Suggested change

	# Generate capture statements for each target call
	replacements = []
	# For the first replacement, use the full leading whitespace
	# For subsequent ones, strip leading newlines to avoid extra blank lines
	base_indent = assertion.leading_whitespace.lstrip("\n\r")
	for i, call in enumerate(assertion.target_calls):
	self.invocation_counter += 1
	var_name = f"_cf_result{self.invocation_counter}"
	if i == 0:
	replacements.append(f"{assertion.leading_whitespace}Object {var_name} = {call.full_call};")
	else:
	replacements.append(f"{base_indent}Object {var_name} = {call.full_call};")
	# Fast path for single call (most common case)
	if len(assertion.target_calls) == 1:
	self.invocation_counter += 1
	call = assertion.target_calls[0]
	return f"{assertion.leading_whitespace}Object _cf_result{self.invocation_counter} = {call.full_call};"
	# Generate capture statements for each target call
	replacements = []
	# For the first replacement, use the full leading whitespace
	# For subsequent ones, strip leading newlines to avoid extra blank lines
	base_indent = assertion.leading_whitespace.lstrip("\n\r")
	# First call uses full leading whitespace
	self.invocation_counter += 1
	call = assertion.target_calls[0]
	replacements.append(f"{assertion.leading_whitespace}Object _cf_result{self.invocation_counter} = {call.full_call};")
	# Subsequent calls use base indent
	for call in assertion.target_calls[1:]:
	self.invocation_counter += 1
	replacements.append(f"{base_indent}Object _cf_result{self.invocation_counter} = {call.full_call};")

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 19% (0.19x) speedup for transform_java_assertions in codeflash/languages/java/remove_asserts.py

⏱️ Runtime : 27.3 milliseconds → 23.0 milliseconds (best of 91 runs)

A dependent PR with the suggested changes has been created. Please review:

• ⚡️ Speed up function transform_java_assertions by 19% in PR #1199 (omni-java) #1365

If you approve, it will be merged into this PR (branch omni-java).

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 19% (0.19x) speedup for insert_method in codeflash/languages/java/replacement.py

⏱️ Runtime : 9.33 milliseconds → 7.81 milliseconds (best of 154 runs)

A dependent PR with the suggested changes has been created. Please review:

• ⚡️ Speed up function insert_method by 19% in PR #1199 (omni-java) #1366

If you approve, it will be merged into this PR (branch omni-java).

[codeflash-ai]

⚡️Codeflash found 700% (7.00x) speedup for JavaSupport.remove_test_functions in codeflash/languages/java/support.py

⏱️ Runtime : 2.81 milliseconds → 352 microseconds (best of 243 runs)

📝 Explanation and details

The optimized code achieves a 699% speedup (2.81ms → 352μs) by eliminating expensive repeated operations and adopting a batch processing approach.

Key Optimizations:

1. Single Parse Instead of Multiple: The original code called remove_method() for each function to remove, which internally parsed the source code every time. The optimized version parses once with analyzer.find_methods() and processes all removals in a single pass.

2. Set-Based Membership Checks: Converting functions_to_remove to a set (functions_to_remove_set = set(functions_to_remove)) changes the membership test from O(n) list scanning to O(1) hash lookup. This is particularly impactful when removing many methods.

3. Direct Line Deletion: Instead of calling remove_method() which reconstructs the entire source string for each removal, the optimized code:

   • Splits the source into lines once: lines = test_source.splitlines(keepends=True)
   • Performs in-place deletions: del lines[start_line - 1 : end_line]
   • Joins lines once at the end: return "".join(lines)

4. Eliminated Object Creation Overhead: The original code created a FunctionToOptimize object and Path("temp.java") for every method removal (70.2% of runtime according to line profiler). The optimized version works directly with method metadata.

5. Early Exit: Added if not methods_to_remove: return test_source to avoid unnecessary work when no methods need removal.

Performance Analysis from Tests:

• Single method removal: 309% faster (24.2μs → 5.93μs)
• Multiple adjacent methods: 472-484% faster
• Large-scale test (200 methods, removing ~67): 3537% faster (2.44ms → 67.0μs)

The optimization excels when removing multiple methods from larger codebases, which aligns with typical test suite refactoring workflows where developers remove batches of obsolete or flaky tests. The reverse-order deletion strategy (sorting by start_line descending) ensures line numbers remain valid throughout the deletion process.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from types import \
    SimpleNamespace  # lightweight container for method-like nodes

# imports
import pytest  # used for our unit tests
from codeflash.languages.java.replacement import remove_test_functions
from codeflash.languages.java.support import JavaSupport

# NOTE:
# The JavaSupport.remove_test_functions method delegates work to
# codeflash.languages.java.replacement.remove_test_functions which in turn
# calls analyzer.find_methods(...) to get method descriptors.
# The real JavaAnalyzer requires tree-sitter and internal parsing helpers
# which are not available in this test environment. To keep tests focused on
# the behavior of remove_test_functions while preserving the real function
# implementation, we instantiate a real JavaSupport and then monkey-patch
# its internal analyzer's find_methods method to return controlled
# SimpleNamespace objects that mimic the attributes the replacement code
# expects: name, class_name, javadoc_start_line, start_line, end_line.
#
# We avoid defining any fake domain classes; SimpleNamespace is a standard
# library container and is safe to use for attribute-based test doubles.
# We also do not modify the implementation of remove_test_functions itself.

def _make_method_node(name, start_line, end_line, class_name=None, javadoc_start_line=None):
    """Helper to create a simple method-like node expected by the analyzer.
    Attributes reflect what the replacement code accesses.
    """
    return SimpleNamespace(
        name=name,
        class_name=class_name,
        javadoc_start_line=javadoc_start_line,
        start_line=start_line,
        end_line=end_line,
    )

def test_basic_remove_single_test_function():
    # Build a small Java test file with three methods: helper, testOne (with javadoc), other.
    lines = [
        "public class MyTests {\n",                 # 1
        "\n",                                      # 2
        "    void helper() {\n",                   # 3
        "    }\n",                                 # 4
        "\n",                                      # 5
        "    /** Javadoc for testOne */\n",        # 6 <-- javadoc start
        "    @Test\n",                             # 7
        "    void testOne() {\n",                  # 8 <-- method start
        "        assert true;\n",                  # 9
        "    }\n",                                 # 10 <-- method end
        "\n",                                      # 11
        "    void other() {\n",                    # 12
        "    }\n",                                 # 13
        "}\n",                                     # 14
    ]
    source = "".join(lines)

    # Create method nodes with accurate 1-based line numbers.
    methods = [
        _make_method_node("helper", start_line=3, end_line=4, class_name="MyTests", javadoc_start_line=None),
        _make_method_node("testOne", start_line=8, end_line=10, class_name="MyTests", javadoc_start_line=6),
        _make_method_node("other", start_line=12, end_line=13, class_name="MyTests", javadoc_start_line=None),
    ]

    js = JavaSupport()  # real instance; its _analyzer will be monkey-patched below

    # Replace the analyzer.find_methods method on this instance to return our prepared nodes.
    js._analyzer.find_methods = lambda src: methods

    # Remove the test function 'testOne'
    codeflash_output = js.remove_test_functions(source, ["testOne"]); result = codeflash_output # 24.2μs -> 5.93μs (309% faster)

def test_remove_noop_when_method_not_found():
    # Source with a single method named 'existing'
    src_lines = [
        "class Example {\n",           # 1
        "    void existing() {}\n",    # 2
        "}\n",                         # 3
    ]
    source = "".join(src_lines)

    methods = [
        _make_method_node("existing", start_line=2, end_line=2, class_name="Example"),
    ]

    js = JavaSupport()
    js._analyzer.find_methods = lambda src: methods

    # Attempt to remove a method that doesn't exist in the analyzer result
    codeflash_output = js.remove_test_functions(source, ["nonExistentTest"]); result = codeflash_output # 2.27μs -> 2.63μs (13.7% slower)

def test_remove_multiple_methods_order_and_javadoc_inclusion():
    # Build a source where two test methods exist and the top one has javadoc.
    lines = [
        "public class C {\n",                 #1
        "\n",                                  #2
        "    /** doc for A */\n",              #3 javadoc start for A
        "    @Test\n",                         #4
        "    void testA() {}\n",               #5 start & end (single-line body)
        "\n",                                  #6
        "    @Test\n",                         #7
        "    void testB() {\n",                #8
        "        // body\n",                   #9
        "    }\n",                             #10
        "\n",                                  #11
        "    void helper() {}\n",              #12
        "}\n",                                 #13
    ]
    source = "".join(lines)

    methods = [
        _make_method_node("testA", start_line=5, end_line=5, class_name="C", javadoc_start_line=3),
        _make_method_node("testB", start_line=8, end_line=10, class_name="C", javadoc_start_line=None),
        _make_method_node("helper", start_line=12, end_line=12, class_name="C"),
    ]

    js = JavaSupport()
    js._analyzer.find_methods = lambda src: methods

    # Remove both testA and testB in a single call to ensure sorting by start_line descending works
    codeflash_output = js.remove_test_functions(source, ["testA", "testB"]); result = codeflash_output # 34.3μs -> 5.99μs (472% faster)

def test_remove_adjacent_methods_and_preserve_surrounding_whitespace():
    # Methods directly follow one another (no blank line between). Confirm removal handles adjacency.
    lines = [
        "class Adj {\n",                      #1
        "    @Test\n",                        #2
        "    void testFirst() {}\n",          #3
        "    @Test\n",                        #4
        "    void testSecond() {}\n",         #5
        "    void kept() {}\n",               #6
        "}\n",                                #7
    ]
    source = "".join(lines)

    methods = [
        _make_method_node("testFirst", start_line=3, end_line=3, class_name="Adj"),
        _make_method_node("testSecond", start_line=5, end_line=5, class_name="Adj"),
        _make_method_node("kept", start_line=6, end_line=6, class_name="Adj"),
    ]

    js = JavaSupport()
    js._analyzer.find_methods = lambda src: methods

    # Remove both adjacent test methods
    codeflash_output = js.remove_test_functions(source, ["testFirst", "testSecond"]); result = codeflash_output # 31.7μs -> 5.43μs (484% faster)

def test_large_scale_removals_under_1000_limit():
    # Large-scale test: construct a file with many small methods (<1000) and remove a subset.
    # We keep total method count under 1000 (use 200) to conform to constraints.
    method_count = 200  # well under 1000
    header = ["public class Large {\n", "\n"]
    body_lines = []
    methods = []
    current_line = len(header) + 1  # start counting from header length + 1 (1-based lines)

    # Build many methods each occupying 3 lines (signature, body, closing) plus a blank line
    for i in range(method_count):
        name = f"test_{i}"
        # each method block: "@Test\n", "void <name>() {\n", "}\n", "\n"
        # record the starting and ending lines for the method body (we'll count lines as we append)
        javadoc = None
        # Start line is the line where "void <name>() {" appears, which will be current_line + 1
        start_line = current_line + 1
        end_line = start_line + 1  # "}" immediately follows in this compact representation
        methods.append(_make_method_node(name, start_line=start_line, end_line=end_line, class_name="Large", javadoc_start_line=javadoc))
        # Append lines for this method block
        body_lines.append("    @Test\n")
        body_lines.append(f"    void {name}() {{\n")
        body_lines.append("    }\n")
        body_lines.append("\n")
        current_line += 4  # we added four lines for each method

    footer = ["}\n"]
    source = "".join(header + body_lines + footer)

    js = JavaSupport()
    js._analyzer.find_methods = lambda src: methods

    # Remove every 3rd test to create a substantial but bounded removal workload
    to_remove = [f"test_{i}" for i in range(0, method_count, 3)]

    codeflash_output = js.remove_test_functions(source, to_remove); result = codeflash_output # 2.44ms -> 67.0μs (3537% faster)

    # Assert that removed names are not present and that non-removed names are still present
    for i in range(method_count):
        name = f"test_{i}"
        if i % 3 == 0:
            pass
        else:
            pass
# 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
from unittest.mock import MagicMock, Mock, patch

import pytest
from codeflash.discovery.functions_to_optimize import FunctionToOptimize
from codeflash.languages.java.parser import JavaAnalyzer, JavaMethodNode
from codeflash.languages.java.replacement import remove_test_functions
from codeflash.languages.java.support import JavaSupport

def test_remove_test_functions_single_method():
    """Test removing a single test method from source code."""
    # Setup: Create a JavaSupport instance
    support = JavaSupport()
    
    # Test source with one test method
    test_source = """
public class MyTests {
    @Test
    public void testExample() {
        assertEquals(1, 1);
    }
    
    @Test
    public void testOther() {
        assertEquals(2, 2);
    }
}
"""
    
    # Remove only testExample
    functions_to_remove = ["testExample"]
    
    # Mock the analyzer to return method information
    mock_analyzer = Mock(spec=JavaAnalyzer)
    method1 = Mock()
    method1.name = "testExample"
    method1.start_line = 3
    method1.end_line = 5
    method1.javadoc_start_line = None
    method1.class_name = "MyTests"
    
    method2 = Mock()
    method2.name = "testOther"
    method2.start_line = 7
    method2.end_line = 9
    method2.javadoc_start_line = None
    method2.class_name = "MyTests"
    
    mock_analyzer.find_methods.return_value = [method1, method2]
    
    # Patch the remove_method function to simulate actual removal
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        # Simulate the actual behavior
        result = test_source.replace(
            "    @Test\n    public void testExample() {\n        assertEquals(1, 1);\n    }\n    \n",
            ""
        )
        mock_remove.return_value = result
        
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 13.8μs -> 12.7μs (8.17% faster)
        mock_remove.assert_called_once_with(test_source, functions_to_remove, support._analyzer)

def test_remove_test_functions_multiple_methods():
    """Test removing multiple test methods from source code."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    @Test
    public void testOne() {
        assertTrue(true);
    }
    
    @Test
    public void testTwo() {
        assertFalse(false);
    }
    
    @Test
    public void testThree() {
        assertEquals(3, 3);
    }
}
"""
    
    functions_to_remove = ["testOne", "testThree"]
    
    # Verify that the function is called with correct parameters
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.7μs -> 12.1μs (5.48% faster)
        mock_remove.assert_called_once()

def test_remove_test_functions_empty_list():
    """Test removing zero test methods (empty functions_to_remove list)."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    @Test
    public void testExample() {
        assertEquals(1, 1);
    }
}
"""
    
    functions_to_remove = []
    
    # With empty list, source should remain unchanged
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.2μs -> 11.4μs (6.94% faster)

def test_remove_test_functions_nonexistent_method():
    """Test removing a method that doesn't exist in source code."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    @Test
    public void testExample() {
        assertEquals(1, 1);
    }
}
"""
    
    # Try to remove a method that doesn't exist
    functions_to_remove = ["nonexistentMethod"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        # Should return unchanged source when method not found
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.3μs -> 11.6μs (5.33% faster)

def test_remove_test_functions_with_javadoc():
    """Test removing a method that has Javadoc comments."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    /**
     * This tests the example functionality.
     */
    @Test
    public void testExample() {
        assertEquals(1, 1);
    }
}
"""
    
    functions_to_remove = ["testExample"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        # Should remove Javadoc as well
        result_without_javadoc = """
public class MyTests {
}
"""
        mock_remove.return_value = result_without_javadoc
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.5μs -> 11.7μs (6.14% faster)
        mock_remove.assert_called_once()

def test_remove_test_functions_preserves_other_methods():
    """Test that removing one method preserves other methods intact."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    @Test
    public void testToRemove() {
        assertTrue(true);
    }
    
    @Test
    public void testToKeep() {
        assertFalse(false);
    }
    
    public void helperMethod() {
        System.out.println("helper");
    }
}
"""
    
    functions_to_remove = ["testToRemove"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.1μs -> 11.1μs (8.93% faster)

def test_remove_test_functions_case_sensitive():
    """Test that method name removal is case-sensitive."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    @Test
    public void testExample() {
        assertEquals(1, 1);
    }
}
"""
    
    # Try removing with different case
    functions_to_remove = ["testexample"]  # lowercase
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source  # Should not remove anything
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.0μs -> 11.2μs (7.07% faster)

def test_remove_test_functions_with_annotations():
    """Test removing methods with multiple annotations."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    @DisplayName("Test Example")
    @Tag("unit")
    @Test
    public void testExample() {
        assertEquals(1, 1);
    }
}
"""
    
    functions_to_remove = ["testExample"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = """
public class MyTests {
}
"""
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 11.9μs -> 11.2μs (5.90% faster)
        mock_remove.assert_called_once()

def test_remove_test_functions_with_parameters():
    """Test removing test methods that have parameters."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3})
    public void testWithParams(int value) {
        assertTrue(value > 0);
    }
}
"""
    
    functions_to_remove = ["testWithParams"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = """
public class MyTests {
}
"""
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 11.8μs -> 11.3μs (4.81% faster)
        mock_remove.assert_called_once()

def test_remove_test_functions_similar_names():
    """Test removing methods when similar method names exist."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    @Test
    public void testExample() {
        assertEquals(1, 1);
    }
    
    @Test
    public void testExampleHelper() {
        assertEquals(2, 2);
    }
}
"""
    
    # Remove only testExample, not testExampleHelper
    functions_to_remove = ["testExample"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.0μs -> 11.3μs (6.37% faster)

def test_remove_test_functions_whitespace_variations():
    """Test removing methods with various whitespace patterns."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    @Test
    public void testExample()
    {
        assertEquals(1, 1);
    }
}
"""
    
    functions_to_remove = ["testExample"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = """
public class MyTests {
}
"""
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 11.9μs -> 11.5μs (3.84% faster)
        mock_remove.assert_called_once()

def test_remove_test_functions_nested_classes():
    """Test removing test methods from nested test classes."""
    support = JavaSupport()
    
    test_source = """
public class OuterTests {
    @Test
    public void testOuter() {
        assertEquals(1, 1);
    }
    
    public static class InnerTests {
        @Test
        public void testInner() {
            assertEquals(2, 2);
        }
    }
}
"""
    
    functions_to_remove = ["testInner"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.0μs -> 11.1μs (7.66% faster)
        mock_remove.assert_called_once()

def test_remove_test_functions_with_multiline_statements():
    """Test removing methods with complex multiline statements."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    @Test
    public void testComplex() {
        assertThat(someList)
            .isNotEmpty()
            .contains("value");
    }
}
"""
    
    functions_to_remove = ["testComplex"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = """
public class MyTests {
}
"""
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.0μs -> 11.2μs (6.50% faster)
        mock_remove.assert_called_once()

def test_remove_test_functions_empty_source():
    """Test removing from empty or minimal source code."""
    support = JavaSupport()
    
    test_source = ""
    functions_to_remove = ["testExample"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 11.9μs -> 11.2μs (6.72% faster)

def test_remove_test_functions_only_class_definition():
    """Test removing from source with only class definition."""
    support = JavaSupport()
    
    test_source = "public class MyTests { }"
    functions_to_remove = ["testExample"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 11.8μs -> 11.2μs (5.09% faster)

def test_remove_test_functions_many_methods():
    """Test removing functions from source with many test methods (500+)."""
    support = JavaSupport()
    
    # Generate source with 500 test methods
    methods = []
    for i in range(500):
        methods.append(f"""    @Test
    public void test{i}() {{
        assertEquals({i}, {i});
    }}
    """)
    
    test_source = "public class ManyTests {\n" + "".join(methods) + "\n}"
    
    # Remove methods at various indices
    functions_to_remove = ["test0", "test100", "test250", "test499"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.2μs -> 11.5μs (5.29% faster)

def test_remove_test_functions_large_source_size():
    """Test removing from very large source files (multiple classes)."""
    support = JavaSupport()
    
    # Create large source with 50 test classes, each with 20 methods
    classes = []
    for c in range(50):
        methods = []
        for m in range(20):
            methods.append(f"""    @Test
    public void testClass{c}Method{m}() {{
        assertEquals({c * 20 + m}, {c * 20 + m});
    }}
    """)
        classes.append(f"public class TestClass{c} {{\n" + "".join(methods) + "\n}\n")
    
    test_source = "".join(classes)
    
    # Remove 100 methods from different classes
    functions_to_remove = [f"testClass{i//20}Method{i%20}" for i in range(100)]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.4μs -> 11.7μs (6.44% faster)

def test_remove_test_functions_batch_removal():
    """Test removing all methods from a batch in order."""
    support = JavaSupport()
    
    # Create 200 methods and remove them all
    methods = []
    for i in range(200):
        methods.append(f"""    @Test
    public void testBatch{i}() {{
        assertTrue(true);
    }}
    """)
    
    test_source = "public class BatchTests {\n" + "".join(methods) + "\n}"
    
    functions_to_remove = [f"testBatch{i}" for i in range(200)]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = "public class BatchTests {\n}"
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.5μs -> 11.6μs (7.86% faster)

def test_remove_test_functions_partial_batch():
    """Test removing subset of methods from large batch."""
    support = JavaSupport()
    
    # Create 300 methods but only remove some
    methods = []
    for i in range(300):
        methods.append(f"""    @Test
    public void testPartial{i}() {{
        assertEquals({i}, {i});
    }}
    """)
    
    test_source = "public class PartialTests {\n" + "".join(methods) + "\n}"
    
    # Remove every 3rd method
    functions_to_remove = [f"testPartial{i}" for i in range(0, 300, 3)]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.3μs -> 11.6μs (5.78% faster)

def test_remove_test_functions_mixed_method_types():
    """Test removing from source with mixed test and non-test methods."""
    support = JavaSupport()
    
    # Create mix of test methods (500) and helper methods (100)
    test_methods = []
    for i in range(500):
        test_methods.append(f"""    @Test
    public void test{i}() {{
        helper{i % 100}();
    }}
    """)
    
    helper_methods = []
    for i in range(100):
        helper_methods.append(f"""    public void helper{i}() {{
        System.out.println("helper {i}");
    }}
    """)
    
    test_source = "public class MixedTests {\n" + "".join(test_methods) + "".join(helper_methods) + "\n}"
    
    # Remove half of test methods
    functions_to_remove = [f"test{i}" for i in range(0, 500, 2)]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.4μs -> 11.7μs (6.07% faster)

def test_remove_test_functions_sequential_removal():
    """Test removing methods in sequential order."""
    support = JavaSupport()
    
    # Create sequential methods and remove in order
    methods = []
    for i in range(100):
        methods.append(f"""    @Test
    public void seq{i:03d}() {{
        assertTrue(true);
    }}
    """)
    
    test_source = "public class SequentialTests {\n" + "".join(methods) + "\n}"
    
    # Remove in exact order they appear
    functions_to_remove = [f"seq{i:03d}" for i in range(100)]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = "public class SequentialTests {\n}"
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.0μs -> 11.5μs (3.90% faster)

def test_remove_test_functions_reverse_order_removal():
    """Test removing methods when functions list is in reverse order."""
    support = JavaSupport()
    
    # Create methods
    methods = []
    for i in range(150):
        methods.append(f"""    @Test
    public void rev{i}() {{
        assertEquals(true, true);
    }}
    """)
    
    test_source = "public class ReverseTests {\n" + "".join(methods) + "\n}"
    
    # Remove in reverse order
    functions_to_remove = [f"rev{i}" for i in range(149, -1, -1)]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = "public class ReverseTests {\n}"
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.4μs -> 11.5μs (7.68% faster)

def test_remove_test_functions_duplicate_names_in_list():
    """Test removing when functions_to_remove contains duplicate names."""
    support = JavaSupport()
    
    test_source = """
public class MyTests {
    @Test
    public void testExample() {
        assertEquals(1, 1);
    }
}
"""
    
    # List with duplicates
    functions_to_remove = ["testExample", "testExample", "testExample"]
    
    with patch('codeflash.languages.java.support.remove_test_functions') as mock_remove:
        mock_remove.return_value = test_source
        codeflash_output = support.remove_test_functions(test_source, functions_to_remove); output = codeflash_output # 12.3μs -> 11.6μs (5.67% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To test or edit this optimization locally git merge codeflash/optimize-pr1199-2026-02-04T02.52.46

Click to see suggested changes

Suggested change

	# Sort by start line in reverse order (remove from end first)
	methods_to_remove = [
	m for m in methods if m.name in functions_to_remove
	]
	methods_to_remove.sort(key=lambda m: m.start_line, reverse=True)
	result = test_source
	for method in methods_to_remove:
	# Create a FunctionToOptimize for removal
	func_info = FunctionToOptimize(
	function_name=method.name,
	file_path=Path("temp.java"),
	starting_line=method.start_line,
	ending_line=method.end_line,
	parents=[],
	is_method=True,
	language="java",
	)
	result = remove_method(result, func_info, analyzer)
	return result
	# Convert to set for O(1) membership checks
	functions_to_remove_set = set(functions_to_remove)
	# Sort by start line in reverse order (remove from end first)
	methods_to_remove = [
	m for m in methods if m.name in functions_to_remove_set
	]
	methods_to_remove.sort(key=lambda m: m.start_line, reverse=True)
	if not methods_to_remove:
	return test_source
	lines = test_source.splitlines(keepends=True)
	for method in methods_to_remove:
	start_line = method.javadoc_start_line or method.start_line
	end_line = method.end_line
	del lines[start_line - 1 : end_line]
	return "".join(lines)

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 48% (0.48x) speedup for _add_java_class_members in codeflash/code_utils/code_replacer.py

⏱️ Runtime : 47.3 milliseconds → 32.0 milliseconds (best of 82 runs)

A dependent PR with the suggested changes has been created. Please review:

• ⚡️ Speed up function _add_java_class_members by 48% in PR #1199 (omni-java) #1368

If you approve, it will be merged into this PR (branch omni-java).

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 29% (0.29x) speedup for _extract_class_declaration in codeflash/languages/java/context.py

⏱️ Runtime : 236 microseconds → 183 microseconds (best of 18 runs)

A dependent PR with the suggested changes has been created. Please review:

• ⚡️ Speed up function _extract_class_declaration by 29% in PR #1199 (omni-java) #1371

If you approve, it will be merged into this PR (branch omni-java).

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 148% (1.48x) speedup for JavaImportResolver._is_external_library in codeflash/languages/java/import_resolver.py

⏱️ Runtime : 584 microseconds → 236 microseconds (best of 177 runs)

A dependent PR with the suggested changes has been created. Please review:

• ⚡️ Speed up method JavaImportResolver._is_external_library by 148% in PR #1199 (omni-java) #1372

If you approve, it will be merged into this PR (branch omni-java).

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 17% (0.17x) speedup for is_test_file in codeflash/languages/java/test_discovery.py

⏱️ Runtime : 609 microseconds → 521 microseconds (best of 220 runs)

A dependent PR with the suggested changes has been created. Please review:

• ⚡️ Speed up function is_test_file by 17% in PR #1199 (omni-java) #1373

If you approve, it will be merged into this PR (branch omni-java).

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 52% (0.52x) speedup for FunctionOptimizer._get_java_sources_root in codeflash/optimization/function_optimizer.py

⏱️ Runtime : 202 microseconds → 133 microseconds (best of 25 runs)

A dependent PR with the suggested changes has been created. Please review:

• ⚡️ Speed up method FunctionOptimizer._get_java_sources_root by 52% in PR #1199 (omni-java) #1374

If you approve, it will be merged into this PR (branch omni-java).

[claude]

Re-review Summary (Commit 95cc603)

✅ Pre-commit Checks

Skipped auto-fixing linting issues as they require unsafe code changes (not just formatting). The following issues remain:

• G004: 29 instances of f-strings in logging statements (should use lazy % formatting)
• PTH110: 4 instances of os.path.exists() (should use Path.exists())
• PERF402, RUF034, RUF059, FURB171, PLW0108: Various performance and style issues

These are non-critical and can be addressed in a follow-up PR.

✅ Existing Comments

All 18 existing review comments have been resolved in previous commits.

✅ Latest Changes Review

Reviewed recent commits (95cc603, 610e63c, 9e81b2b, dbb26df):

• Style fixes (9e81b2b): Fixed 89 linting issues across 26 files ✅
• Verbose logging (4ced2fb, 2c48e9c): Added DEBUG_MODE checks for verbose logging in optimization pipeline ✅
• Test timeout (5b65b27): Increased Java test timeout from 15s to 120s (appropriate for JVM startup overhead) ✅
• Instrumented test cleanup (1b911c0, d69b8c5): Fixed handling of numbered suffixes in Java test files ✅

No critical bugs, security vulnerabilities, or breaking API changes found.

⚠️ Coverage Analysis

New Java Files (All Added in This PR)

File	Coverage	Status
java/__init__.py	100%	✅ Excellent
java/parser.py	98%	✅ Excellent
java/config.py	89%	✅ Good
java/discovery.py	88%	✅ Good
java/context.py	86%	✅ Good
java/import_resolver.py	86%	✅ Good
java/remove_asserts.py	86%	✅ Good
java/instrumentation.py	85%	✅ Good
java/test_discovery.py	85%	✅ Good
java/support.py	72%	⚠️ Below 75%
java/formatter.py	64%	⚠️ Below 75%
java/replacement.py	60%	⚠️ Below 75%
java/build_tools.py	55%	⚠️ Below 75%
java/test_runner.py	54%	⚠️ Below 75%
java/comparator.py	47%	⚠️ Below 75%

Modified Existing Files

File	Coverage	Notes
optimization/function_optimizer.py	20%	Low but unchanged from main
optimization/optimizer.py	21%	Low but unchanged from main
cli_cmds/init_java.py	17%	New file, needs more tests
api/aiservice.py	15%	Low but unchanged from main

📊 Overall Coverage

• Total Coverage: 52% across all changed files
• Java Module Coverage: 73% average (includes 10 files at 85%+ coverage)

🎯 Recommendations

1. Priority: Add tests for the 5 Java files below 75% coverage:

   • comparator.py (47%) - critical for test result comparison
   • test_runner.py (54%) - critical for running tests
   • build_tools.py (55%) - important for Maven/Gradle integration
   • replacement.py (60%) - critical for code replacement
   • formatter.py (64%) - important for code formatting

2. Consider addressing linting issues (G004, PTH110, etc.) in a follow-up PR for cleaner code

3. The Java implementation is solid with most core modules having excellent test coverage (85%+)

✅ Approval Status

Ready to merge with the understanding that test coverage for 5 Java modules should be improved in a follow-up PR. The core functionality is well-tested and the implementation is sound.