⚡️ Speed up function _generate_sqlite_write_code by 54% in PR #1638 (loop-id-calculation-fix-bug)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1638

If you approve this dependent PR, these changes will be merged into the original PR branch loop-id-calculation-fix-bug.

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

---

📄 54% (0.54x) speedup for _generate_sqlite_write_code in codeflash/languages/java/instrumentation.py

⏱️ Runtime : 9.66 milliseconds → 6.28 milliseconds (best of 185 runs)

📝 Explanation and details

The optimized code achieves a 53% speedup (from 9.66ms to 6.28ms) by eliminating redundant f-string interpolations through strategic pre-computation of commonly used variable names.

Key Optimization: The original code repeatedly performs the same f-string interpolation f"{iter_id}_{call_counter}" throughout the 35-line return statement. The optimized version pre-computes this pattern once as iter_counter, then reuses it to build all variable names like cf_end_var, cf_dur_var, etc. This transforms expensive repeated string formatting operations into cheap variable lookups.

Why This Works:

• F-string interpolation has overhead for parsing the template and converting values to strings on each execution
• The original code performs these interpolations 11 times for iter_id+call_counter combinations and 6 times for iter_id-only patterns
• By computing these strings once upfront (lines that add ~1.5% overhead), we eliminate repetitive work that was consuming ~24% of total time in the return list construction
• Python's string interning and variable lookups are highly optimized, making the pre-computed variable references nearly free

Test Results: The optimization shows consistent speedups across all test cases:

• Simple cases: 20-35% faster (e.g., basic functionality test: 7.90μs → 6.43μs)
• Large-scale iteration test (1000 calls): 57.4% faster (5.50ms → 3.49ms), demonstrating the compounding benefit when the function is called repeatedly
• Deep nesting/long parameters: Still 14-24% faster even with extreme inputs

This optimization is particularly valuable given the function generates instrumentation code, meaning it likely runs frequently during code analysis or testing workflows. The speedup compounds significantly in bulk operations without changing behavior or correctness.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import pytest  # used for our unit tests
from codeflash.languages.java.instrumentation import \
    _generate_sqlite_write_code

def test_basic_functionality_small_numbers():
    # Basic test: small positive integers and a simple indent
    iter_id = 1
    call_counter = 2
    indent = "  "  # two spaces as base indentation
    # supply class/func/test names (function under test does not use them, but we pass realistic values)
    class_name = "MyTestClass"
    func_name = "testedFunction"
    test_method_name = "test_method"

    # Generate the code lines
    codeflash_output = _generate_sqlite_write_code(iter_id, call_counter, indent, class_name, func_name, test_method_name); lines = codeflash_output # 7.90μs -> 6.43μs (22.9% faster)

    # inner_indent should be base indent plus four spaces
    inner_indent = indent + "    "

    # Ensure the System.out.println line contains the inserted call_counter as a quoted Java literal (e.g. "2")
    # The function places the numeric call_counter inside Java quotes inside the generated Java code.
    expected_print_fragment = f':" + "{call_counter}" + "######!");'.replace("{call_counter}", str(call_counter))

    # Confirm the CREATE TABLE SQL fragment is present across multiple lines (ensures SQL structure preserved)
    create_table_fragments = [
        'CREATE TABLE IF NOT EXISTS test_results (',
        'test_module_path TEXT, test_class_name TEXT, test_function_name TEXT, ',
        'function_getting_tested TEXT, loop_index INTEGER, iteration_id TEXT, ',
        'runtime INTEGER, return_value BLOB, verification_type TEXT)'
    ]
    # Each fragment should appear in one of the generated lines
    for frag in create_table_fragments:
        pass

def test_ignores_class_and_func_names_with_special_chars():
    # The function signature accepts class_name/func_name/test_method_name but the implementation
    # currently does not use them. We pass unusual strings and assert they do not appear in output.
    iter_id = 7
    call_counter = 11
    indent = "    "  # four spaces
    # strings with special characters which should NOT appear in the generated code (function doesn't use them)
    class_name = 'Strange<Class>{}"'
    func_name = "fun\nction\tweird"
    test_method_name = "test/with\\slashes"

    codeflash_output = _generate_sqlite_write_code(iter_id, call_counter, indent, class_name, func_name, test_method_name); lines = codeflash_output # 7.88μs -> 6.16μs (27.9% faster)

    combined = "\n".join(lines)

def test_negative_ids_and_empty_indent():
    # Edge case: negative iter_id and zero call_counter, with empty indent
    iter_id = -1
    call_counter = 0
    indent = ""  # empty indent should be supported
    class_name = "C"
    func_name = "f"
    test_method_name = "t"

    codeflash_output = _generate_sqlite_write_code(iter_id, call_counter, indent, class_name, func_name, test_method_name); lines = codeflash_output # 7.98μs -> 6.19μs (28.9% faster)

def test_large_numbers_and_tab_indent():
    # Edge test: very large numbers and a tab character as base indent
    iter_id = 123456789
    call_counter = 987654321
    indent = "\t"  # a single tab; inner_indent should be tab + four spaces
    codeflash_output = _generate_sqlite_write_code(iter_id, call_counter, indent, "C", "f", "t"); lines = codeflash_output # 8.74μs -> 6.67μs (30.9% faster)

    # Verify that the inner indentation is tab + four spaces at the start of lines that use it
    inner_indent = indent + "    "

    # The large numeric identifiers must be embedded verbatim in variable names
    test_var = f"_cf_conn{iter_id}_{call_counter}"

def test_uniqueness_over_many_calls_large_scale():
    # Large-scale test: generate outputs for 1000 successive call_counter values and ensure distinctness
    iter_id = 5
    indent = ""  # keep indent empty to keep lines minimal for the large loop
    class_name = "BulkTest"
    func_name = "bulkFunction"
    test_method_name = "bulk_test"

    seen_print_lines = set()
    seen_pstmt_lines = set()

    # Generate for call_counter in range 1000 to ensure performance and uniqueness
    for call_counter in range(1000):
        codeflash_output = _generate_sqlite_write_code(iter_id, call_counter, indent, class_name, func_name, test_method_name); lines = codeflash_output # 5.50ms -> 3.49ms (57.4% faster)

        # Extract the println line (index 3) and the setString(6, ...) line to verify uniqueness
        println_line = lines[3]
        # find the line with setString(6, "N");
        setstring6_line = next((l for l in lines if 'setString(6, "' in l), None)
        seen_print_lines.add(println_line)
        seen_pstmt_lines.add(setstring6_line)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest
from codeflash.languages.java.instrumentation import \
    _generate_sqlite_write_code

def test_basic_functionality_simple_case():
    """Test basic functionality with simple input values."""
    # Call the function with typical parameters
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testMethod",
        test_method_name="test_example"
    ); result = codeflash_output # 8.48μs -> 7.09μs (19.5% faster)

def test_return_type_is_list_of_strings():
    """Test that the function returns a list of strings."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=0,
        call_counter=0,
        indent="",
        class_name="MyClass",
        func_name="myFunc",
        test_method_name="my_test"
    ); result = codeflash_output # 8.05μs -> 6.59μs (22.2% faster)
    # Verify all elements in the list are strings
    for line in result:
        pass

def test_output_contains_finally_block():
    """Test that output contains the finally block opening."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 8.02μs -> 6.39μs (25.4% faster)

def test_output_contains_system_nanotime():
    """Test that output contains System.nanoTime() calls."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.49μs -> 6.11μs (22.6% faster)

def test_output_contains_sqlite_jdbc_class():
    """Test that output contains SQLite JDBC class reference."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.64μs -> 5.96μs (28.2% faster)

def test_output_contains_prepared_statement():
    """Test that output contains PreparedStatement code."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.48μs -> 5.87μs (27.5% faster)

def test_iter_id_used_in_variable_names():
    """Test that iter_id is correctly incorporated in variable names."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=42,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.92μs -> 6.25μs (26.8% faster)
    
    # Assert that iter_id appears in generated variable names
    result_text = " ".join(result)

def test_call_counter_used_in_variable_names():
    """Test that call_counter is correctly incorporated in variable names."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=5,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.81μs -> 5.96μs (31.1% faster)
    
    # Assert that call_counter appears in generated variable names
    result_text = " ".join(result)

def test_indent_applied_to_lines():
    """Test that indent is correctly applied to generated lines."""
    indent_str = "        "  # 8 spaces
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent=indent_str,
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 8.00μs -> 6.45μs (23.9% faster)

def test_output_contains_table_creation_sql():
    """Test that output contains SQL table creation statement."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.73μs -> 6.18μs (25.1% faster)
    
    # Assert that CREATE TABLE statement is present
    result_text = " ".join(result)

def test_output_contains_insert_statement():
    """Test that output contains SQL INSERT statement."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.52μs -> 5.93μs (26.9% faster)
    
    # Assert that INSERT statement is present
    result_text = " ".join(result)

def test_output_contains_error_handling():
    """Test that output contains exception handling."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.62μs -> 5.87μs (29.9% faster)

def test_iter_id_zero():
    """Test with iter_id set to 0."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=0,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.29μs -> 5.81μs (25.5% faster)
    
    # Assert that result contains _cf_end0_
    result_text = " ".join(result)

def test_iter_id_negative():
    """Test with negative iter_id."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=-1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 8.01μs -> 6.08μs (31.6% faster)

def test_call_counter_zero():
    """Test with call_counter set to 0."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.72μs -> 5.98μs (29.2% faster)
    
    # Assert that result contains _0 suffixes
    result_text = " ".join(result)

def test_call_counter_large():
    """Test with large call_counter value."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=999999,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 8.21μs -> 6.45μs (27.2% faster)
    
    # Assert that large call_counter is properly used in variable names
    result_text = " ".join(result)

def test_empty_indent():
    """Test with empty indent string."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.55μs -> 5.97μs (26.5% faster)

def test_long_indent():
    """Test with a very long indent string."""
    long_indent = "    " * 10  # 40 spaces
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent=long_indent,
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.90μs -> 6.43μs (22.9% faster)

def test_tab_indent():
    """Test with tab character as indent."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="\t",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.73μs -> 5.96μs (29.7% faster)

def test_mixed_indent():
    """Test with mixed spaces and tabs."""
    indent_str = "\t  "  # tab followed by spaces
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent=indent_str,
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.78μs -> 6.15μs (26.5% faster)

def test_class_name_empty():
    """Test with empty class name."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.69μs -> 6.05μs (27.2% faster)

def test_func_name_empty():
    """Test with empty function name."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="",
        test_method_name="test_run"
    ); result = codeflash_output # 7.55μs -> 5.87μs (28.7% faster)

def test_test_method_name_empty():
    """Test with empty test method name."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name=""
    ); result = codeflash_output # 7.48μs -> 5.86μs (27.7% faster)

def test_class_name_with_special_chars():
    """Test with class name containing special characters."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass$Inner#2",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.67μs -> 5.61μs (36.6% faster)

def test_func_name_with_special_chars():
    """Test with function name containing special characters."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="test_func<String>",
        test_method_name="test_run"
    ); result = codeflash_output # 7.51μs -> 5.84μs (28.7% faster)

def test_with_unicode_class_name():
    """Test with unicode characters in class name."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass_日本語",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.42μs -> 5.54μs (34.0% faster)

def test_with_unicode_func_name():
    """Test with unicode characters in function name."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc_中文",
        test_method_name="test_run"
    ); result = codeflash_output # 7.64μs -> 5.82μs (31.3% faster)

def test_output_list_not_empty():
    """Test that output list always contains lines."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.60μs -> 5.79μs (31.3% faster)

def test_output_list_consistency():
    """Test that function always returns same structure for same inputs."""
    # Call function twice with identical parameters
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result1 = codeflash_output # 7.49μs -> 5.68μs (31.9% faster)
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result2 = codeflash_output # 6.41μs -> 4.83μs (32.8% faster)

def test_output_contains_connection_try_with_resources():
    """Test that output uses try-with-resources for connection."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.64μs -> 5.69μs (34.3% faster)
    
    # Assert that connection is created with try-with-resources
    result_text = " ".join(result)

def test_output_contains_statement_try_with_resources():
    """Test that output uses try-with-resources for statement."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.52μs -> 5.58μs (34.8% faster)
    
    # Assert that statement is created with try-with-resources
    result_text = " ".join(result)

def test_output_contains_prepared_statement_try_with_resources():
    """Test that output uses try-with-resources for prepared statement."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.52μs -> 5.96μs (26.2% faster)
    
    # Assert that prepared statement is created with try-with-resources
    result_text = " ".join(result)

def test_output_contains_all_setters():
    """Test that output contains all required setString/setInt/setLong/setBytes calls."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.57μs -> 5.72μs (32.4% faster)
    
    result_text = " ".join(result)

def test_output_contains_execute_update():
    """Test that output calls executeUpdate()."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.63μs -> 5.72μs (33.5% faster)

def test_output_contains_verification_type():
    """Test that output sets verification_type to 'function_call'."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.54μs -> 5.87μs (28.5% faster)
    
    # Assert that verification_type is set to "function_call"
    result_text = " ".join(result)

def test_output_closing_braces_matched():
    """Test that output has matched opening and closing braces."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.50μs -> 5.93μs (26.5% faster)
    
    # Join all lines and count braces
    code = " ".join(result)
    open_braces = code.count("{")
    close_braces = code.count("}")

def test_large_iter_id():
    """Test with very large iter_id value."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1000000,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 8.42μs -> 6.65μs (26.5% faster)
    result_text = " ".join(result)

def test_large_call_counter():
    """Test with very large call_counter value."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=1000000,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 8.49μs -> 6.39μs (32.8% faster)
    result_text = " ".join(result)

def test_very_long_class_name():
    """Test with very long class name."""
    long_class_name = "TestClass" + "Extension" * 100
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name=long_class_name,
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 7.88μs -> 6.16μs (28.0% faster)

def test_very_long_func_name():
    """Test with very long function name."""
    long_func_name = "testFunc" + "_test" * 100
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name=long_func_name,
        test_method_name="test_run"
    ); result = codeflash_output # 7.65μs -> 6.03μs (26.9% faster)

def test_very_long_test_method_name():
    """Test with very long test method name."""
    long_test_method_name = "test_" + "method" * 100
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name=long_test_method_name
    ); result = codeflash_output # 7.57μs -> 5.93μs (27.7% faster)

def test_very_long_indent():
    """Test with extremely long indent string."""
    very_long_indent = " " * 1000  # 1000 spaces
    codeflash_output = _generate_sqlite_write_code(
        iter_id=1,
        call_counter=0,
        indent=very_long_indent,
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 10.3μs -> 9.04μs (14.5% faster)

def test_multiple_sequential_calls():
    """Test multiple sequential calls with increasing counters."""
    results = []
    for i in range(100):
        codeflash_output = _generate_sqlite_write_code(
            iter_id=1,
            call_counter=i,
            indent="",
            class_name="TestClass",
            func_name="testFunc",
            test_method_name="test_run"
        ); result = codeflash_output # 573μs -> 377μs (51.9% faster)
        results.append(result)

def test_varying_all_parameters_1000_combinations():
    """Test function with 1000 different parameter combinations."""
    iter_ids = [0, 1, 10, 100, 1000]
    call_counters = [0, 1, 10, 100, 1000]
    indents = ["", "  ", "    ", "\t", "        "]
    
    count = 0
    # Create combinations and test
    for iter_id in iter_ids:
        for call_counter in call_counters:
            for indent in indents:
                for idx in range(4):  # 4 more variations
                    codeflash_output = _generate_sqlite_write_code(
                        iter_id=iter_id,
                        call_counter=call_counter,
                        indent=indent,
                        class_name=f"TestClass{idx}",
                        func_name=f"testFunc{idx}",
                        test_method_name=f"test_run_{idx}"
                    ); result = codeflash_output
                    count += 1
                    if count >= 1000:
                        break
            if count >= 1000:
                break
        if count >= 1000:
            break

def test_output_line_count_consistency():
    """Test that output always has same number of lines."""
    results = []
    for i in range(50):
        codeflash_output = _generate_sqlite_write_code(
            iter_id=i,
            call_counter=i,
            indent="    " * (i % 5),
            class_name=f"TestClass{i}",
            func_name=f"testFunc{i}",
            test_method_name=f"test_run_{i}"
        ); result = codeflash_output # 310μs -> 206μs (50.0% faster)
        results.append(result)
    
    # Assert that all results have same number of lines
    line_counts = [len(r) for r in results]

def test_large_iter_and_counter_values():
    """Test with large values for both iter_id and call_counter."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=999999,
        call_counter=999999,
        indent="",
        class_name="TestClass",
        func_name="testFunc",
        test_method_name="test_run"
    ); result = codeflash_output # 8.82μs -> 7.13μs (23.6% faster)
    
    # Verify handling of large numbers
    result_text = " ".join(result)

def test_all_parameters_maximum_values():
    """Test with maximum reasonable values for all parameters."""
    codeflash_output = _generate_sqlite_write_code(
        iter_id=999999,
        call_counter=999999,
        indent="    " * 20,  # Deep indentation
        class_name="VeryLongTestClassName" * 10,
        func_name="veryLongFunctionNameToBeTested" * 10,
        test_method_name="test_very_long_method_name" * 10
    ); result = codeflash_output # 9.07μs -> 7.31μs (24.0% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr1638-2026-02-23T05.48.46 and push.

[claude]

PR Review Summary

Prek Checks

• Auto-fixed: 3 trailing whitespace issues in codeflash/languages/java/instrumentation.py (committed and pushed as 720edf0b)
• Remaining (not auto-fixable):
  • SLF001 in codeflash/cli_cmds/init_java.py:439 — private member accessed _warning_shown (pre-existing in base branch, not introduced by this PR)
  • N806 in codeflash/languages/java/instrumentation.py:235 — variable cf_outputFile_ref should be lowercase (introduced by this PR optimization)

Code Review

No critical issues found. This PR pre-computes commonly used f-string variable names into local variables in _generate_sqlite_write_code. All variable mappings verified correct — the generated Java code is functionally identical to the original.

• iter_counter, cf_end_var, cf_dur_var, etc. all resolve to the same strings as before
• Reference variables (cf_mod_ref, cf_cls_ref, etc.) correctly use iter_id only
• Counter variables correctly use iter_id_{call_counter}

Note: The N806 ruff warning for cf_outputFile_ref is because the Java variable it maps to is _cf_outputFile (camelCase). Renaming the Python variable to cf_output_file_ref would be the ruff-compliant fix but does not affect correctness.

Test Coverage

File	Stmts	Miss	Coverage
codeflash/languages/java/instrumentation.py	599	108	82%

• This file is new relative to main (added in the base branch loop-id-calculation-fix-bug)
• The optimization is a pure refactoring of _generate_sqlite_write_code — no new code paths added, no coverage change expected
• 82% coverage meets the ≥75% threshold for new files

CI Status

CI checks from the previous commit show failures in prek (due to the two remaining ruff issues above), unit-tests, and several Java/JS e2e tests. These failures appear to be inherited from the base branch. A new CI run should be in progress after the whitespace fix commit.

---

Last updated: 2026-02-23

[codeflash-ai]

This PR has been automatically closed because the original PR #1638 by misrasaurabh1 was closed.