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

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1199

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

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

---

📄 20% (0.20x) speedup for get_java_runtime_setup_steps in codeflash/cli_cmds/init_java.py

⏱️ Runtime : 531 microseconds → 441 microseconds (best of 203 runs)

📝 Explanation and details

This optimization achieves a 20% runtime improvement (531μs → 441μs) by replacing conditional string concatenation with a precomputed dictionary lookup.

What changed:

• The original code builds strings dynamically on every function call, performing string concatenation operations based on conditional checks
• The optimized version precomputes all possible string outputs once at module load time and stores them in a dictionary (_JAVA_SETUP_MAP)
• The function now performs a simple O(1) dictionary lookup instead of executing string operations

Why it's faster:

1. Eliminates repeated string operations: String concatenation in Python creates new string objects. The original code performs this work on every call, while the optimized version does it once at module initialization
2. Reduces conditional branching: The original code evaluates two conditional branches per call. The optimized version performs a single dictionary lookup, which is highly optimized in Python's C implementation
3. Better CPU cache utilization: Precomputed strings stored in memory are more likely to remain in CPU cache across multiple function calls

Performance characteristics by test case:

• Single calls: Show mixed results (some 3-15% slower per individual call) due to dictionary lookup overhead, but the overall benchmark shows 20% improvement
• Repeated calls (500 iterations): Show strong gains of 17-27% faster, where the optimization truly shines. This is where the elimination of repeated string operations matters most
• Subsequent calls: Tests with multiple consecutive calls (result1, result2, result3) show increasing speedup on later calls (up to 25% faster), indicating better memory access patterns

Impact on workloads:
This function generates GitHub Actions workflow configuration. The optimization is most beneficial when:

• The function is called multiple times during workflow generation (common in CI/CD setup scenarios)
• Build configurations are generated in batch operations
• The same build tool type is queried repeatedly

The trade-off of slightly slower individual first-time calls is more than compensated by the significant gains in repeated execution scenarios, making this a net-positive optimization for typical usage patterns where configuration generation happens in batches or loops.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from enum import Enum  # used to define the JavaBuildTool enum for the tests

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

# function to test (preserve the original implementation exactly)
class JavaBuildTool(Enum):
    # Define the tools that the function checks for.
    MAVEN = "maven"
    GRADLE = "gradle"
    OTHER = "other"

def test_maven_appends_maven_cache_exact():
    """
    Basic case: When the build tool is MAVEN, the returned setup steps
    should exactly equal the base block plus the maven cache line.
    This verifies precise string concatenation and whitespace preservation.
    """
    # Expected base string - must match the function's base literal exactly.
    base = """- name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'"""
    # Expected final string for MAVEN (base + newline + 10-space indentation + cache line).
    expected = base + "\n          cache: 'maven'"

    codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 851ns -> 1.24μs (31.5% slower)

def test_gradle_appends_gradle_cache_exact():
    """
    Basic case: When the build tool is GRADLE, the returned setup steps
    should exactly equal the base block plus the gradle cache line.
    This test ensures the GRADLE branch is handled correctly.
    """
    base = """- name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'"""
    expected = base + "\n          cache: 'gradle'"

    codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result = codeflash_output # 832ns -> 1.00μs (17.0% slower)

def test_other_tool_does_not_append_cache():
    """
    Edge case: For an unrecognized/other build tool, the function should not
    append any cache configuration. The output must be exactly the base block.
    """
    base = """- name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'"""

    codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); result = codeflash_output # 821ns -> 932ns (11.9% slower)

def test_none_input_returns_base_string():
    """
    Edge case: Passing None (or an unexpected type) should not raise an error.
    Because the function uses equality checks against enum members, None
    should simply fall through and return the base string unchanged.
    """
    base = """- name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'"""

    # Passing None should behave like an unrecognized tool (no cache appended).
    codeflash_output = get_java_runtime_setup_steps(None); result = codeflash_output # 1.02μs -> 451ns (126% faster)

def test_sequential_calls_do_not_accumulate_state():
    """
    Ensure the function is pure (no internal state is mutated across calls).
    Call with MAVEN then with OTHER and ensure the OTHER result does not
    contain the maven cache line that might have been appended erroneously.
    """
    codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result_maven = codeflash_output # 862ns -> 891ns (3.25% slower)
    codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); result_other = codeflash_output # 430ns -> 451ns (4.66% slower)

def test_large_scale_many_calls_performance_and_correctness():
    """
    Large-scale scenario: call the function multiple times (well under the 1000
    loop limit) with alternating tool types and confirm correctness across many calls.
    This checks for performance regressions and ensures deterministic behavior.
    """
    # Number of iterations chosen to be large enough to exercise repeated use,
    # but well below the 1000-iteration limit requested by constraints.
    iterations = 500

    results = []
    # Alternate between MAVEN and GRADLE to ensure both branches are exercised repeatedly.
    for i in range(iterations):
        if i % 2 == 0:
            results.append(get_java_runtime_setup_steps(JavaBuildTool.MAVEN))
        else:
            results.append(get_java_runtime_setup_steps(JavaBuildTool.GRADLE))

    # Check that each even index contains maven cache and not gradle cache.
    for i in range(0, iterations, 2):
        res = results[i]

    # Check that each odd index contains gradle cache and not maven cache.
    for i in range(1, iterations, 2):
        res = results[i]

    # Aggregate assertions to ensure both caches appeared the expected number of times.
    maven_count = sum(1 for r in results if "cache: 'maven'" in r)
    gradle_count = sum(1 for r in results if "cache: 'gradle'" in r)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from enum import Enum

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

# Define JavaBuildTool enum for testing
class JavaBuildTool(Enum):
    """Enum for Java build tools"""
    MAVEN = "maven"
    GRADLE = "gradle"
    OTHER = "other"

class TestGetJavaRuntimeSetupStepsBasic:
    """Basic test cases for get_java_runtime_setup_steps function"""
    
    def test_returns_string_type(self):
        """Test that the function returns a string"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 942ns -> 1.11μs (15.3% slower)
    
    def test_returns_non_empty_string(self):
        """Test that the function returns a non-empty string"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 932ns -> 982ns (5.09% slower)
    
    def test_contains_setup_java_action(self):
        """Test that the result contains the setup-java action reference"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 822ns -> 902ns (8.87% slower)
    
    def test_contains_jdk_17_version(self):
        """Test that the result specifies JDK 17"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 871ns -> 901ns (3.33% slower)
    
    def test_contains_temurin_distribution(self):
        """Test that the result uses temurin distribution"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 821ns -> 861ns (4.65% slower)
    
    def test_maven_build_tool_includes_maven_cache(self):
        """Test that Maven build tool results include maven cache configuration"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 832ns -> 832ns (0.000% faster)
    
    def test_gradle_build_tool_includes_gradle_cache(self):
        """Test that Gradle build tool results include gradle cache configuration"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result = codeflash_output # 831ns -> 932ns (10.8% slower)
    
    def test_other_build_tool_no_cache_specified(self):
        """Test that other build tools do not include cache configuration"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); result = codeflash_output # 801ns -> 882ns (9.18% slower)
    
    def test_maven_result_contains_base_setup(self):
        """Test that Maven result contains all base setup steps"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 852ns -> 882ns (3.40% slower)
    
    def test_gradle_result_contains_base_setup(self):
        """Test that Gradle result contains all base setup steps"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result = codeflash_output # 861ns -> 922ns (6.62% slower)

class TestGetJavaRuntimeSetupStepsEdgeCases:
    """Edge case test cases for get_java_runtime_setup_steps function"""
    
    def test_maven_vs_gradle_different_output(self):
        """Test that Maven and Gradle produce different outputs"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); maven_result = codeflash_output # 861ns -> 891ns (3.37% slower)
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); gradle_result = codeflash_output # 450ns -> 501ns (10.2% slower)
    
    def test_maven_gradle_cache_are_mutually_exclusive(self):
        """Test that Maven result does not contain gradle cache and vice versa"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); maven_result = codeflash_output # 812ns -> 892ns (8.97% slower)
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); gradle_result = codeflash_output # 430ns -> 491ns (12.4% slower)
    
    def test_other_build_tool_returns_base_setup_only(self):
        """Test that OTHER build tool returns only base setup without cache"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); result = codeflash_output # 821ns -> 842ns (2.49% slower)
    
    def test_result_is_valid_yaml_format(self):
        """Test that the result follows YAML format conventions"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 831ns -> 862ns (3.60% slower)
    
    def test_maven_cache_line_properly_indented(self):
        """Test that Maven cache line has proper indentation"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 852ns -> 852ns (0.000% faster)
        lines = result.split('\n')
        cache_lines = [line for line in lines if 'cache:' in line]
    
    def test_gradle_cache_line_properly_indented(self):
        """Test that Gradle cache line has proper indentation"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result = codeflash_output # 821ns -> 891ns (7.86% slower)
        lines = result.split('\n')
        cache_lines = [line for line in lines if 'cache:' in line]
    
    def test_output_contains_no_extra_newlines_maven(self):
        """Test that Maven output does not have excessive newlines"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 862ns -> 882ns (2.27% slower)
    
    def test_output_contains_no_extra_newlines_gradle(self):
        """Test that Gradle output does not have excessive newlines"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result = codeflash_output # 841ns -> 871ns (3.44% slower)
    
    def test_single_quotes_used_for_string_values(self):
        """Test that string values are properly quoted with single quotes"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 872ns -> 862ns (1.16% faster)
    
    def test_action_version_is_v4(self):
        """Test that the action version is specifically v4"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 842ns -> 862ns (2.32% slower)

class TestGetJavaRuntimeSetupStepsMultipleCalls:
    """Test cases for multiple calls and consistency"""
    
    def test_consistent_output_for_same_input_maven(self):
        """Test that calling the function multiple times with same input produces identical output"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result1 = codeflash_output # 811ns -> 801ns (1.25% faster)
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result2 = codeflash_output # 441ns -> 451ns (2.22% slower)
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result3 = codeflash_output # 350ns -> 310ns (12.9% faster)
    
    def test_consistent_output_for_same_input_gradle(self):
        """Test that calling the function multiple times with same input produces identical output"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result1 = codeflash_output # 831ns -> 861ns (3.48% slower)
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result2 = codeflash_output # 430ns -> 391ns (9.97% faster)
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result3 = codeflash_output # 360ns -> 301ns (19.6% faster)
    
    def test_consistent_output_for_same_input_other(self):
        """Test that calling the function multiple times with same input produces identical output"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); result1 = codeflash_output # 811ns -> 852ns (4.81% slower)
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); result2 = codeflash_output # 411ns -> 400ns (2.75% faster)
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); result3 = codeflash_output # 351ns -> 281ns (24.9% faster)

class TestGetJavaRuntimeSetupStepsLargeScale:
    """Large scale test cases for performance and scalability"""
    
    def test_performance_with_many_consecutive_calls_maven(self):
        """Test that the function performs well with many consecutive calls"""
        import time
        
        start_time = time.time()
        for _ in range(500):
            get_java_runtime_setup_steps(JavaBuildTool.MAVEN) # 164μs -> 139μs (17.7% faster)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
    
    def test_performance_with_many_consecutive_calls_gradle(self):
        """Test that the function performs well with many consecutive calls"""
        import time
        
        start_time = time.time()
        for _ in range(500):
            get_java_runtime_setup_steps(JavaBuildTool.GRADLE) # 162μs -> 131μs (23.6% faster)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
    
    def test_performance_with_many_consecutive_calls_other(self):
        """Test that the function performs well with many consecutive calls"""
        import time
        
        start_time = time.time()
        for _ in range(500):
            get_java_runtime_setup_steps(JavaBuildTool.OTHER) # 162μs -> 128μs (26.6% faster)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
    
    def test_all_build_tools_consistency_across_many_calls(self):
        """Test that all build tools maintain consistency across many calls"""
        build_tools = [JavaBuildTool.MAVEN, JavaBuildTool.GRADLE, JavaBuildTool.OTHER]
        
        for build_tool in build_tools:
            results = [get_java_runtime_setup_steps(build_tool) for _ in range(100)]
    
    def test_output_string_length_reasonable_maven(self):
        """Test that Maven output string length is reasonable and not excessive"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 942ns -> 851ns (10.7% faster)
    
    def test_output_string_length_reasonable_gradle(self):
        """Test that Gradle output string length is reasonable and not excessive"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result = codeflash_output # 872ns -> 812ns (7.39% faster)
    
    def test_output_string_length_reasonable_other(self):
        """Test that Other output string length is reasonable and not excessive"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); result = codeflash_output # 801ns -> 781ns (2.56% faster)
    
    def test_line_count_is_reasonable_maven(self):
        """Test that Maven output has a reasonable number of lines"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 871ns -> 791ns (10.1% faster)
        lines = result.split('\n')
    
    def test_line_count_is_reasonable_gradle(self):
        """Test that Gradle output has a reasonable number of lines"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result = codeflash_output # 841ns -> 812ns (3.57% faster)
        lines = result.split('\n')
    
    def test_line_count_is_reasonable_other(self):
        """Test that Other output has a reasonable number of lines"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); result = codeflash_output # 742ns -> 751ns (1.20% slower)
        lines = result.split('\n')

class TestGetJavaRuntimeSetupStepsContentValidation:
    """Test cases for validating the content and structure of the output"""
    
    def test_maven_output_line_count(self):
        """Test that Maven output has exactly the expected number of lines"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 821ns -> 801ns (2.50% faster)
        lines = result.split('\n')
    
    def test_gradle_output_line_count(self):
        """Test that Gradle output has exactly the expected number of lines"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result = codeflash_output # 831ns -> 801ns (3.75% faster)
        lines = result.split('\n')
    
    def test_other_output_line_count(self):
        """Test that Other output has fewer lines than Maven/Gradle"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); other_result = codeflash_output # 801ns -> 722ns (10.9% faster)
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); maven_result = codeflash_output # 431ns -> 501ns (14.0% slower)
        
        other_lines = len(other_result.split('\n'))
        maven_lines = len(maven_result.split('\n'))
    
    def test_each_build_tool_produces_distinct_output(self):
        """Test that each build tool produces a unique output"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); maven_result = codeflash_output # 831ns -> 732ns (13.5% faster)
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); gradle_result = codeflash_output # 421ns -> 471ns (10.6% slower)
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); other_result = codeflash_output # 340ns -> 320ns (6.25% faster)
        
        # All three should be different
        results = [maven_result, gradle_result, other_result]
    
    def test_base_structure_common_to_all_build_tools(self):
        """Test that base structure is common to all build tools"""
        common_strings = [
            "- name: Set up JDK 17",
            "uses: actions/setup-java@v4",
            "with:",
            "java-version: '17'",
            "distribution: 'temurin'"
        ]
        
        for build_tool in [JavaBuildTool.MAVEN, JavaBuildTool.GRADLE, JavaBuildTool.OTHER]:
            codeflash_output = get_java_runtime_setup_steps(build_tool); result = codeflash_output # 1.53μs -> 1.50μs (2.13% faster)
            for common_string in common_strings:
                pass
    
    def test_maven_contains_exactly_one_cache_directive(self):
        """Test that Maven output contains exactly one cache directive"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.MAVEN); result = codeflash_output # 822ns -> 771ns (6.61% faster)
        # Count occurrences of cache: in the result
        cache_count = result.count("cache: 'maven'")
    
    def test_gradle_contains_exactly_one_cache_directive(self):
        """Test that Gradle output contains exactly one cache directive"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.GRADLE); result = codeflash_output # 832ns -> 782ns (6.39% faster)
        # Count occurrences of cache: in the result
        cache_count = result.count("cache: 'gradle'")
    
    def test_other_contains_no_cache_directive(self):
        """Test that Other output contains no cache directive"""
        codeflash_output = get_java_runtime_setup_steps(JavaBuildTool.OTHER); result = codeflash_output # 781ns -> 732ns (6.69% 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-pr1199-2026-02-01T21.47.41 and push.