⚡️ Speed up function _validate_test_filter by 19% in PR #1319 (feat/java-gradle-support)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1319

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

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

---

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

⏱️ Runtime : 794 microseconds → 666 microseconds (best of 105 runs)

📝 Explanation and details

The optimized code achieves a 19% runtime improvement through two key optimizations:

1. Fast-path for single class names (most common case): The optimization adds an early exit for test filters without commas or wildcards - the typical case where developers run a single test class. By checking "," not in test_filter and "*" not in test_filter upfront, the code validates the stripped name directly with the regex and returns immediately, avoiding the split operation and loop entirely. Test results show this path benefits dramatically: single class names run 39-46% faster (e.g., test_single_valid_class_name improved from 2.95μs to 2.11μs).

2. Eliminating intermediate list allocation: For multi-pattern filters, the code now iterates directly over test_filter.split(",") instead of building a list comprehension with [p.strip() for p in test_filter.split(",")]. This avoids allocating and populating an intermediate list, reducing memory pressure and iteration overhead. Tests with multiple patterns show 10-23% improvements (e.g., test_many_comma_separated_patterns improved from 34.2μs to 27.9μs).

The line profiler data confirms the impact: the original code spent 10.3% of time (699μs) building the patterns list, while the optimized version eliminates this entirely. The fast-path also shows clear wins - for simple single-name inputs (the most frequent use case in Maven test execution), the optimized version completes validation in ~2μs versus ~3μs.

Why this matters: Test filtering is invoked during Maven build processes where developers frequently run individual test classes during development. The 40% speedup for single test names and 20% average improvement for bulk operations makes CI/CD pipelines and local test iterations noticeably faster, especially in projects with hundreds of test classes.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 90 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
# Import the real functions from the real module under test.
# The tests exercise the actual implementation of _validate_test_filter
# and _validate_java_class_name as provided in the codebase.
from codeflash.languages.java.test_runner import (_validate_java_class_name,
                                                  _validate_test_filter)

def test_single_valid_class_name_returns_same_string():
    # Basic single class name should be accepted and returned unchanged.
    input_filter = "MyTest"
    codeflash_output = _validate_test_filter(input_filter); result = codeflash_output # 2.95μs -> 2.11μs (39.4% faster)

def test_multiple_valid_class_names_with_commas_and_spaces():
    # Multiple class names separated by commas and spaces should be validated.
    # Note: the function strips whitespace only for validation, but returns the original string.
    input_filter = "com.example.MyTest, OtherTest ,org.pkg.AnotherTest"
    codeflash_output = _validate_test_filter(input_filter); result = codeflash_output # 4.37μs -> 3.86μs (13.2% faster)

def test_wildcards_allowed_in_various_positions():
    # Wildcards (*) are allowed anywhere in patterns. They are replaced with 'A' internally for validation.
    inputs = [
        "*MyTest",      # wildcard at start
        "My*Test",      # wildcard in middle
        "MyTest*",      # wildcard at end
        "*",            # only wildcard
        "com.*.MyTest", # wildcard as package part
        "***Inner",     # multiple wildcards
    ]
    for pattern in inputs:
        # each pattern should be considered valid and returned as-is
        codeflash_output = _validate_test_filter(pattern) # 8.42μs -> 7.47μs (12.6% faster)

@pytest.mark.parametrize(
    "invalid_filter",
    [
        "",               # empty string -> invalid (no class)
        "My Test",        # space inside name -> invalid
        "My-Test",        # hyphen not allowed by regex
        "com/example",    # slash not allowed
        "1StartsWithDigit",  # starts with digit -> invalid
        ".startsWithDot",     # starts with dot -> invalid
        "NameWith,Comma,",    # trailing comma creates empty pattern -> invalid
        ",LeadingComma",      # leading comma creates empty pattern -> invalid
    ],
)
def test_invalid_patterns_raise_value_error(invalid_filter):
    # Each of these inputs is malformed and must raise ValueError
    with pytest.raises(ValueError):
        _validate_test_filter(invalid_filter) # 37.1μs -> 30.8μs (20.6% faster)

def test_patterns_with_only_wildcards_and_other_allowed_chars():
    # Patterns made of wildcards and permitted characters should pass.
    codeflash_output = _validate_test_filter("***") # 3.14μs -> 2.82μs (11.4% faster)
    codeflash_output = _validate_test_filter("*$Inner") # 1.30μs -> 1.23μs (5.68% faster)

def test_input_with_surrounding_whitespace_returns_original_string():
    # The function strips whitespace around patterns for validation but returns the original string.
    input_filter = "  MyTest  ,  OtherTest "
    codeflash_output = _validate_test_filter(input_filter); result = codeflash_output # 4.04μs -> 3.68μs (9.85% faster)

def test_empty_pattern_among_valid_patterns_raises():
    # When one of the comma-separated patterns is empty (e.g., "A,,B" or trailing comma),
    # the function should detect it and raise ValueError.
    with pytest.raises(ValueError):
        _validate_test_filter("ValidTest,,Another") # 5.75μs -> 5.48μs (4.93% faster)
    with pytest.raises(ValueError):
        _validate_test_filter("ValidTest,") # 2.99μs -> 2.92μs (2.44% faster)
    with pytest.raises(ValueError):
        _validate_test_filter(",ValidTest") # 2.24μs -> 2.06μs (8.72% faster)

def test_large_number_of_valid_patterns_is_handled_quickly():
    # Create a large but bounded number of valid test patterns (500 items).
    # Each pattern is a simple valid Java identifier-based test name.
    num_patterns = 500
    patterns = [f"Test{name}" for name in range(num_patterns)]
    big_filter = ",".join(patterns)  # join into a single test_filter string
    # Should validate and return the exact same string
    codeflash_output = _validate_test_filter(big_filter); result = codeflash_output # 161μs -> 137μs (17.2% faster)

def test_large_number_with_one_invalid_pattern_fails():
    # Create many valid patterns and insert a single invalid one in the middle.
    num_patterns = 300
    patterns = [f"GoodTest{i}" for i in range(num_patterns)]
    patterns.insert(num_patterns // 2, "Bad Test With Space")  # insert invalid one
    big_filter = ",".join(patterns)
    with pytest.raises(ValueError):
        _validate_test_filter(big_filter) # 64.3μs -> 51.1μs (26.0% faster)
# 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.test_runner import _validate_test_filter

def test_single_valid_class_name():
    """Test validation of a single, simple Java class name."""
    codeflash_output = _validate_test_filter("MyTest"); result = codeflash_output # 3.42μs -> 2.44μs (39.8% faster)

def test_single_valid_fully_qualified_class_name():
    """Test validation of a fully qualified Java class name with package."""
    codeflash_output = _validate_test_filter("com.example.MyTest"); result = codeflash_output # 3.02μs -> 2.13μs (41.3% faster)

def test_single_valid_class_with_underscore():
    """Test validation of a class name containing underscores."""
    codeflash_output = _validate_test_filter("My_Test"); result = codeflash_output # 2.85μs -> 2.03μs (39.9% faster)

def test_single_valid_class_with_dollar_sign():
    """Test validation of an inner class name (with dollar sign)."""
    codeflash_output = _validate_test_filter("OuterClass$InnerTest"); result = codeflash_output # 2.85μs -> 2.04μs (39.7% faster)

def test_multiple_valid_class_names():
    """Test validation of multiple comma-separated class names."""
    codeflash_output = _validate_test_filter("MyTest,OtherTest,AnotherTest"); result = codeflash_output # 4.36μs -> 3.69μs (18.2% faster)

def test_class_name_with_wildcard():
    """Test validation of a class name with a wildcard pattern."""
    codeflash_output = _validate_test_filter("My*Test"); result = codeflash_output # 3.02μs -> 2.81μs (7.48% faster)

def test_multiple_patterns_with_wildcards():
    """Test validation of multiple patterns with wildcards."""
    codeflash_output = _validate_test_filter("My*Test,Other*Test"); result = codeflash_output # 3.91μs -> 3.54μs (10.5% faster)

def test_class_name_starting_with_underscore():
    """Test validation of a class name starting with an underscore."""
    codeflash_output = _validate_test_filter("_TestClass"); result = codeflash_output # 2.87μs -> 2.03μs (40.9% faster)

def test_class_name_starting_with_dollar_sign():
    """Test validation of a class name starting with a dollar sign."""
    codeflash_output = _validate_test_filter("$TestClass"); result = codeflash_output # 3.02μs -> 2.06μs (46.1% faster)

def test_class_name_with_digits():
    """Test validation of a class name containing digits."""
    codeflash_output = _validate_test_filter("Test123Class456"); result = codeflash_output # 2.85μs -> 2.12μs (33.9% faster)

def test_fully_qualified_name_with_digits_and_underscores():
    """Test validation of a complex fully qualified class name."""
    codeflash_output = _validate_test_filter("com.example_1.my_test.Test_2"); result = codeflash_output # 2.90μs -> 2.11μs (36.9% faster)

def test_whitespace_handling_single_space():
    """Test that whitespace around class names is properly trimmed."""
    codeflash_output = _validate_test_filter("  MyTest  "); result = codeflash_output # 3.00μs -> 2.14μs (39.7% faster)

def test_whitespace_handling_between_commas():
    """Test that whitespace around commas is properly handled."""
    codeflash_output = _validate_test_filter("MyTest , OtherTest , ThirdTest"); result = codeflash_output # 4.39μs -> 3.96μs (10.9% faster)

def test_multiple_wildcards_in_pattern():
    """Test validation of patterns with multiple wildcard characters."""
    codeflash_output = _validate_test_filter("*Test*"); result = codeflash_output # 3.08μs -> 2.81μs (9.27% faster)

def test_leading_wildcard_only():
    """Test validation of pattern with only leading wildcard."""
    codeflash_output = _validate_test_filter("*Test"); result = codeflash_output # 3.02μs -> 2.71μs (11.5% faster)

def test_trailing_wildcard_only():
    """Test validation of pattern with only trailing wildcard."""
    codeflash_output = _validate_test_filter("Test*"); result = codeflash_output # 3.00μs -> 2.75μs (8.75% faster)

def test_wildcard_in_middle():
    """Test validation of wildcard in the middle of a pattern."""
    codeflash_output = _validate_test_filter("Test*Class"); result = codeflash_output # 2.92μs -> 2.75μs (5.84% faster)

def test_invalid_class_name_with_hyphen():
    """Test that class names with hyphens are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My-Test") # 5.16μs -> 4.16μs (24.1% faster)

def test_invalid_class_name_with_space():
    """Test that class names with spaces are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My Test") # 4.69μs -> 3.79μs (23.8% faster)

def test_invalid_class_name_with_at_symbol():
    """Test that class names with @ symbol are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My@Test") # 4.54μs -> 3.46μs (31.3% faster)

def test_invalid_class_name_with_hash():
    """Test that class names with # symbol are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My#Test") # 4.41μs -> 3.47μs (27.2% faster)

def test_invalid_class_name_with_semicolon():
    """Test that class names with semicolons are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My;Test") # 4.33μs -> 3.43μs (26.3% faster)

def test_invalid_class_name_with_colon():
    """Test that class names with colons are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My:Test") # 4.41μs -> 3.35μs (31.7% faster)

def test_invalid_class_name_with_parentheses():
    """Test that class names with parentheses are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My(Test)") # 4.48μs -> 3.48μs (28.8% faster)

def test_invalid_class_name_with_brackets():
    """Test that class names with brackets are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My[Test]") # 4.41μs -> 3.44μs (28.3% faster)

def test_invalid_class_name_with_curly_braces():
    """Test that class names with curly braces are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My{Test}") # 4.30μs -> 3.40μs (26.5% faster)

def test_invalid_class_name_with_angle_brackets():
    """Test that class names with angle brackets are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My<Test>") # 4.23μs -> 3.29μs (28.7% faster)

def test_invalid_class_name_with_pipe():
    """Test that class names with pipe character are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My|Test") # 4.29μs -> 3.44μs (24.8% faster)

def test_invalid_class_name_with_ampersand():
    """Test that class names with ampersand are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My&Test") # 4.28μs -> 3.31μs (29.4% faster)

def test_invalid_class_name_with_exclamation():
    """Test that class names with exclamation mark are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My!Test") # 4.30μs -> 3.46μs (24.4% faster)

def test_invalid_class_name_with_question_mark():
    """Test that class names with question mark are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My?Test") # 4.28μs -> 3.37μs (27.1% faster)

def test_invalid_class_name_with_single_quote():
    """Test that class names with single quotes are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My'Test") # 4.54μs -> 3.40μs (33.6% faster)

def test_invalid_class_name_with_double_quote():
    """Test that class names with double quotes are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter('My"Test') # 4.39μs -> 3.49μs (25.9% faster)

def test_invalid_class_name_with_backtick():
    """Test that class names with backticks are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My`Test") # 4.34μs -> 3.46μs (25.5% faster)

def test_invalid_class_name_with_backslash():
    """Test that class names with backslashes are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My\\Test") # 4.30μs -> 3.39μs (26.9% faster)

def test_invalid_class_name_with_forward_slash():
    """Test that class names with forward slashes are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My/Test") # 4.26μs -> 3.35μs (27.3% faster)

def test_invalid_class_name_with_equal_sign():
    """Test that class names with equal signs are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My=Test") # 4.18μs -> 3.40μs (23.0% faster)

def test_invalid_class_name_with_plus_sign():
    """Test that class names with plus signs are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My+Test") # 4.31μs -> 3.24μs (33.1% faster)

def test_invalid_class_name_with_percent_sign():
    """Test that class names with percent signs are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My%Test") # 4.41μs -> 3.45μs (27.9% faster)

def test_invalid_class_name_with_caret():
    """Test that class names with caret character are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My^Test") # 4.29μs -> 3.40μs (26.3% faster)

def test_invalid_class_name_with_tilde():
    """Test that class names with tilde character are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My~Test") # 4.40μs -> 3.49μs (26.1% faster)

def test_invalid_class_name_with_grave_accent():
    """Test that class names with grave accent are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("My`Test") # 4.35μs -> 3.41μs (27.7% faster)

def test_invalid_multiple_patterns_one_invalid():
    """Test that if one pattern is invalid, the entire validation fails."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("ValidTest,Invalid-Test,AnotherValid") # 5.73μs -> 5.66μs (1.24% faster)

def test_invalid_class_name_starts_with_digit():
    """Test that class names starting with a digit are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("1TestClass") # 4.13μs -> 3.22μs (28.3% faster)

def test_empty_string_input():
    """Test that empty string raises ValueError."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("") # 4.90μs -> 3.78μs (29.7% faster)

def test_only_whitespace():
    """Test that only whitespace patterns raise ValueError."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("   ") # 4.64μs -> 3.53μs (31.5% faster)

def test_only_commas():
    """Test that only commas raise ValueError."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter(",,,") # 5.06μs -> 4.85μs (4.33% faster)

def test_trailing_comma():
    """Test that trailing comma creates an empty pattern which is invalid."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("MyTest,") # 6.11μs -> 5.79μs (5.53% faster)

def test_leading_comma():
    """Test that leading comma creates an empty pattern which is invalid."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter(",MyTest") # 4.54μs -> 4.24μs (7.10% faster)

def test_multiple_consecutive_commas():
    """Test that multiple consecutive commas create empty patterns."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("MyTest,,OtherTest") # 5.73μs -> 5.43μs (5.54% faster)

def test_invalid_unicode_character():
    """Test that unicode characters are rejected."""
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter("MyTest\u00e9") # 5.12μs -> 4.13μs (24.0% faster)

def test_invalid_class_name_with_asterisk_at_start_of_qualified_name():
    """Test wildcard patterns with qualified names."""
    codeflash_output = _validate_test_filter("com.example.*Test"); result = codeflash_output # 3.28μs -> 2.98μs (9.75% faster)

def test_invalid_class_with_multiple_dollar_signs():
    """Test class names with multiple dollar signs (nested inner classes)."""
    codeflash_output = _validate_test_filter("Outer$Middle$Inner"); result = codeflash_output # 3.10μs -> 2.12μs (45.7% faster)

def test_invalid_pattern_with_dot_wildcard_combination():
    """Test that dot and wildcard combinations are valid in qualified names."""
    codeflash_output = _validate_test_filter("com.example*.Test*"); result = codeflash_output # 3.13μs -> 2.87μs (9.11% faster)

def test_many_comma_separated_patterns():
    """Test validation of a large number of comma-separated patterns."""
    # Create a list of 100 valid class names
    patterns = ",".join([f"Test{i}" for i in range(100)])
    codeflash_output = _validate_test_filter(patterns); result = codeflash_output # 34.2μs -> 27.9μs (22.6% faster)

def test_deeply_nested_package_structure():
    """Test validation of deeply nested package structures."""
    # Create a deeply nested package name
    package = ".".join([f"package{i}" for i in range(50)])
    package += ".TestClass"
    codeflash_output = _validate_test_filter(package); result = codeflash_output # 3.72μs -> 2.67μs (39.5% faster)

def test_many_patterns_with_wildcards():
    """Test validation of many patterns with wildcards."""
    patterns = ",".join([f"Test{i}*" for i in range(100)])
    codeflash_output = _validate_test_filter(patterns); result = codeflash_output # 37.3μs -> 30.5μs (22.3% faster)

def test_mixed_patterns_large_scale():
    """Test a mix of simple, qualified, and wildcard patterns at large scale."""
    # Create 50 patterns with various formats
    mixed_patterns = []
    for i in range(50):
        if i % 3 == 0:
            mixed_patterns.append(f"Test{i}")
        elif i % 3 == 1:
            mixed_patterns.append(f"com.example.Test{i}")
        else:
            mixed_patterns.append(f"Test{i}*")
    
    pattern_string = ",".join(mixed_patterns)
    codeflash_output = _validate_test_filter(pattern_string); result = codeflash_output # 20.5μs -> 16.6μs (23.1% faster)

def test_maximum_length_pattern():
    """Test validation of a very long pattern string."""
    # Create a single very long class name with many parts
    long_package = ".".join(["package"] * 100) + ".TestClass"
    codeflash_output = _validate_test_filter(long_package); result = codeflash_output # 4.21μs -> 3.06μs (37.7% faster)

def test_many_wildcards_in_single_pattern():
    """Test a single pattern with many wildcard characters."""
    pattern = "*Test*Class*Method*Suite*"
    codeflash_output = _validate_test_filter(pattern); result = codeflash_output # 3.06μs -> 2.96μs (3.37% faster)

def test_alternating_underscores_and_dollars():
    """Test patterns with many underscores and dollar signs."""
    pattern = "_$_$_$Test_$_$_$Class"
    codeflash_output = _validate_test_filter(pattern); result = codeflash_output # 2.89μs -> 1.98μs (45.5% faster)

def test_large_number_of_digits_in_names():
    """Test class names with many digits."""
    pattern = "Test123456789012345678901234567890Class"
    codeflash_output = _validate_test_filter(pattern); result = codeflash_output # 2.90μs -> 2.09μs (38.7% faster)

def test_mixed_case_sensitivity():
    """Test that case sensitivity is preserved and valid."""
    pattern = "TestCLASStestclassTestClass"
    codeflash_output = _validate_test_filter(pattern); result = codeflash_output # 3.03μs -> 2.07μs (45.9% faster)

def test_performance_many_invalid_patterns():
    """Test that validation fails quickly with many invalid patterns."""
    # Create many valid patterns with one invalid at the end
    patterns = ",".join([f"Valid{i}" for i in range(500)])
    patterns += ",Invalid-Test"
    
    with pytest.raises(ValueError, match="Invalid test class name or pattern"):
        _validate_test_filter(patterns) # 153μs -> 136μs (12.7% faster)

def test_large_whitespace_padding():
    """Test handling of multiple spaces around commas."""
    patterns = "Test1  ,  Test2  ,  Test3  ,  Test4  ,  Test5"
    codeflash_output = _validate_test_filter(patterns); result = codeflash_output # 5.24μs -> 4.55μs (15.2% faster)

def test_complex_real_world_patterns():
    """Test realistic complex Maven test filter patterns."""
    pattern = (
        "com.example.service.UserServiceTest,"
        "com.example.service.*ServiceTest,"
        "com.example.integration.*.IntegrationTest*,"
        "com.example.app$InnerTest"
    )
    codeflash_output = _validate_test_filter(pattern); result = codeflash_output # 5.31μs -> 4.72μs (12.5% 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-pr1319-2026-02-04T01.30.32 and push.