⚡️ Speed up function _validate_test_filter by 39% 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.

---

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

⏱️ Runtime : 591 microseconds → 426 microseconds (best of 140 runs)

📝 Explanation and details

The optimized code achieves a 38% runtime improvement by eliminating redundant string operations and function calls during test filter validation.

Key Optimizations

1. Direct Regex Validation with Wildcards
The original code replaced * wildcards with 'A' on every pattern and then called _validate_java_class_name(), which performed another regex match. The optimized version introduces _VALID_JAVA_CLASS_NAME_WITH_WILDCARD that directly accepts * characters in valid positions, eliminating:

• Per-pattern string replacement operations (pattern.replace('*', 'A'))
• Function call overhead to _validate_java_class_name()
• One redundant regex match per pattern

2. Streamlined Loop Structure
Instead of building an intermediate list via list comprehension (patterns = [p.strip() for p in ...]), the optimized code directly iterates over split results. This removes:

• Memory allocation for the intermediate list
• Extra iteration through all patterns before validation begins

Performance Impact

The line profiler shows the optimization concentrates gains in the validation hotpath:

• Original: 3.57ms (74.6% of time) spent in _validate_java_class_name() calls
• Optimized: Direct regex matching takes 0.73ms (47% of time)

Test results confirm consistent improvements across all scenarios:

• Simple single patterns: 34-42% faster (e.g., "MyTest", "com.example.MyTest")
• Wildcard patterns: 42-57% faster (e.g., "My*Test", "Test") - highest gains due to eliminating the replacement operation
• Large-scale tests: 42-57% faster (500 patterns: 158μs → 110μs; 300 patterns: 111μs → 70.7μs)

Why This Matters

Maven test filtering is typically invoked during build and CI/CD pipelines where test discovery happens frequently. Even though individual calls are microseconds, the cumulative effect across hundreds of test invocations in large codebases makes this optimization valuable. The improvements are most pronounced for:

• Filters with wildcards (50%+ faster)
• Comma-separated lists with many patterns (40%+ faster)
• Repeated invocations during test discovery phases

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from __future__ import annotations

import re

# imports
import pytest  # used for our unit tests
from codeflash.languages.java.test_runner import _validate_test_filter

def test_valid_simple_class_name():
    # Basic: simple, valid Java-like class name should be returned unchanged.
    input_filter = "MyTest"
    codeflash_output = _validate_test_filter(input_filter); result = codeflash_output # 3.30μs -> 2.46μs (34.3% faster)

def test_valid_with_package_and_inner_class_and_dollar():
    # Basic: complex but valid Java class pattern with package, inner class dollar and dots
    input_filter = "com.example.MyTest$Inner"
    codeflash_output = _validate_test_filter(input_filter); result = codeflash_output # 3.14μs -> 2.25μs (39.1% faster)

def test_valid_with_wildcards_single_and_multiple():
    # Basic: wildcards are allowed anywhere; multiple '*' should be tolerated
    for pattern in ("My*Test", "*MyTest", "My**Test", "com.*.MyTest"):
        # each pattern must be accepted and returned as-is
        codeflash_output = _validate_test_filter(pattern) # 6.72μs -> 4.34μs (55.0% faster)

def test_multiple_patterns_with_commas_and_whitespace():
    # Basic: comma-separated patterns with extra whitespace should be trimmed per pattern
    input_filter = "  MyTest  , Other_Test$, com.pkg.*  "
    # The function returns the original string (it does not reformat spacing), so expect identical string
    codeflash_output = _validate_test_filter(input_filter); result = codeflash_output # 4.66μs -> 3.34μs (39.7% faster)

def test_invalid_starting_with_digit_raises_value_error():
    # Edge: class names cannot start with a digit; should raise ValueError
    with pytest.raises(ValueError):
        _validate_test_filter("1InvalidStart") # 4.89μs -> 4.01μs (22.0% faster)

def test_invalid_characters_like_semicolon_raise_value_error():
    # Edge: dangerous characters that could be used for command injection are rejected
    with pytest.raises(ValueError):
        _validate_test_filter("MyTest;rm -rf /") # 4.69μs -> 3.75μs (25.1% faster)

def test_empty_string_raises_value_error():
    # Edge: empty overall string (no characters) leads to an empty pattern after split and should be invalid
    with pytest.raises(ValueError):
        _validate_test_filter("") # 3.95μs -> 3.21μs (22.8% faster)

def test_single_wildcard_is_valid():
    # Edge: a single '*' is a valid test filter because it's replaced with 'A' for validation
    codeflash_output = _validate_test_filter("*") # 3.04μs -> 2.14μs (41.6% faster)

def test_dot_prefix_is_invalid():
    # Edge: a pattern starting with a dot is invalid because '.' is not a valid starting character
    with pytest.raises(ValueError):
        _validate_test_filter(".HiddenTest") # 4.22μs -> 3.48μs (21.3% faster)

def test_dollar_prefix_is_valid():
    # Edge: dollar sign as first character is allowed by the regex; ensure it's accepted
    input_filter = "$SecretTest"
    codeflash_output = _validate_test_filter(input_filter) # 2.83μs -> 2.06μs (37.4% faster)

def test_trailing_comma_creates_empty_segment_and_raises():
    # Edge: trailing comma produces an empty (whitespace-stripped) pattern which is invalid
    with pytest.raises(ValueError):
        _validate_test_filter("MyTest,") # 5.46μs -> 4.43μs (23.3% faster)

def test_space_inside_name_is_invalid():
    # Edge: internal spaces are not allowed in Java class names; ensure they're rejected
    with pytest.raises(ValueError):
        _validate_test_filter("My Test") # 4.38μs -> 3.58μs (22.4% faster)

def test_non_string_input_raises_attribute_error():
    # Edge: passing a non-string (None) will cause an AttributeError when split is called; ensure this is raised
    with pytest.raises(AttributeError):
        _validate_test_filter(None) # 2.62μs -> 2.29μs (14.0% faster)

def test_large_scale_many_valid_patterns():
    # Large Scale: generate a relatively large but bounded number of valid patterns to test scalability
    # Keep count under 1000 as required (use 500)
    count = 500
    # create patterns Test0,Test1,...Test499 which are valid (start with letter, only alnum)
    patterns = [f"Test{i}" for i in range(count)]
    joined = ",".join(patterns)  # produce a single large filter string with commas
    # The function should validate all patterns and return the same string
    codeflash_output = _validate_test_filter(joined) # 158μs -> 110μs (42.5% faster)

def test_large_scale_mixed_wildcards_and_packages():
    # Large Scale: many patterns including wildcards and package-like names
    count = 300  # still under 1000
    patterns = [f"com.example.Test{i}*" if i % 3 == 0 else f"pkg.sub.Test_{i}" for i in range(count)]
    joined = ",".join(patterns)
    # Ensure function validates the mixed set correctly
    codeflash_output = _validate_test_filter(joined) # 111μs -> 70.7μs (57.1% 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

class TestValidateTestFilterBasic:
    """Basic test cases for _validate_test_filter function."""

    def test_simple_valid_class_name(self):
        """Test with a simple valid Java class name."""
        codeflash_output = _validate_test_filter("MyTest"); result = codeflash_output # 2.90μs -> 2.12μs (36.3% faster)

    def test_valid_fully_qualified_class_name(self):
        """Test with a valid fully qualified class name (package.ClassName)."""
        codeflash_output = _validate_test_filter("com.example.MyTest"); result = codeflash_output # 2.85μs -> 2.00μs (42.1% faster)

    def test_valid_multiple_packages(self):
        """Test with a valid class name containing multiple package levels."""
        codeflash_output = _validate_test_filter("org.apache.commons.MyTest"); result = codeflash_output # 2.85μs -> 2.11μs (34.6% faster)

    def test_valid_with_underscore(self):
        """Test with a valid class name containing underscores."""
        codeflash_output = _validate_test_filter("My_Test"); result = codeflash_output # 2.77μs -> 1.94μs (42.7% faster)

    def test_valid_with_digits(self):
        """Test with a valid class name containing digits."""
        codeflash_output = _validate_test_filter("Test123"); result = codeflash_output # 2.71μs -> 1.98μs (36.3% faster)

    def test_valid_with_dollar_sign(self):
        """Test with a valid class name containing dollar sign (inner class)."""
        codeflash_output = _validate_test_filter("OuterClass$InnerTest"); result = codeflash_output # 2.75μs -> 1.98μs (38.4% faster)

    def test_valid_single_wildcard(self):
        """Test with a valid pattern containing a single wildcard."""
        codeflash_output = _validate_test_filter("My*Test"); result = codeflash_output # 2.92μs -> 1.95μs (49.7% faster)

    def test_valid_multiple_wildcards(self):
        """Test with a valid pattern containing multiple wildcards."""
        codeflash_output = _validate_test_filter("*Test*"); result = codeflash_output # 2.88μs -> 1.91μs (50.7% faster)

    def test_valid_wildcard_only(self):
        """Test with a pattern that is only a wildcard."""
        codeflash_output = _validate_test_filter("*"); result = codeflash_output # 2.92μs -> 1.86μs (56.5% faster)

    def test_valid_comma_separated_classes(self):
        """Test with multiple comma-separated class names."""
        codeflash_output = _validate_test_filter("MyTest,OtherTest"); result = codeflash_output # 3.57μs -> 2.73μs (30.4% faster)

    def test_valid_comma_separated_with_packages(self):
        """Test with multiple comma-separated fully qualified class names."""
        codeflash_output = _validate_test_filter("com.example.MyTest,org.example.OtherTest"); result = codeflash_output # 3.69μs -> 2.75μs (33.8% faster)

    def test_valid_comma_separated_with_wildcards(self):
        """Test with multiple comma-separated patterns containing wildcards."""
        codeflash_output = _validate_test_filter("My*Test,Other*Test"); result = codeflash_output # 3.73μs -> 2.62μs (42.0% faster)

    def test_whitespace_handling_around_commas(self):
        """Test that whitespace around commas is handled correctly."""
        codeflash_output = _validate_test_filter("MyTest , OtherTest"); result = codeflash_output # 3.75μs -> 2.75μs (36.0% faster)

    def test_starts_with_letter(self):
        """Test that class name starting with letter is valid."""
        codeflash_output = _validate_test_filter("aTest"); result = codeflash_output # 2.90μs -> 2.12μs (36.3% faster)

    def test_starts_with_underscore(self):
        """Test that class name starting with underscore is valid."""
        codeflash_output = _validate_test_filter("_Test"); result = codeflash_output # 2.81μs -> 2.03μs (38.4% faster)

    def test_starts_with_dollar(self):
        """Test that class name starting with dollar sign is valid."""
        codeflash_output = _validate_test_filter("$Test"); result = codeflash_output # 2.77μs -> 1.97μs (40.1% faster)

class TestValidateTestFilterEdgeCases:
    """Edge case test cases for _validate_test_filter function."""

    def test_empty_string_invalid(self):
        """Test that empty string raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("") # 4.44μs -> 3.80μs (16.9% faster)

    def test_whitespace_only_invalid(self):
        """Test that whitespace-only string raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("   ") # 4.08μs -> 3.30μs (23.7% faster)

    def test_starts_with_digit_invalid(self):
        """Test that class name starting with digit raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("9Test") # 4.12μs -> 3.32μs (24.2% faster)

    def test_invalid_character_hash(self):
        """Test that hash character in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("My#Test") # 4.27μs -> 3.60μs (18.7% faster)

    def test_invalid_character_at_sign(self):
        """Test that @ character in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("My@Test") # 4.25μs -> 3.48μs (22.2% faster)

    def test_invalid_character_hyphen(self):
        """Test that hyphen in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("My-Test") # 4.06μs -> 3.38μs (20.2% faster)

    def test_invalid_character_space(self):
        """Test that space in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("My Test") # 4.10μs -> 3.35μs (22.4% faster)

    def test_invalid_character_semicolon(self):
        """Test that semicolon in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest;") # 4.14μs -> 3.50μs (18.3% faster)

    def test_invalid_character_pipe(self):
        """Test that pipe character in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest|OtherTest") # 4.27μs -> 3.45μs (23.9% faster)

    def test_invalid_character_ampersand(self):
        """Test that ampersand in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("My&Test") # 4.14μs -> 3.35μs (23.6% faster)

    def test_invalid_character_parenthesis(self):
        """Test that parenthesis in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest()") # 4.14μs -> 3.46μs (19.7% faster)

    def test_invalid_character_bracket(self):
        """Test that bracket in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest[]") # 4.27μs -> 3.59μs (19.0% faster)

    def test_invalid_character_quote(self):
        """Test that quote in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter('MyTest"') # 4.33μs -> 3.57μs (21.3% faster)

    def test_invalid_character_backtick(self):
        """Test that backtick in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest`") # 4.10μs -> 3.51μs (16.9% faster)

    def test_invalid_character_tilde(self):
        """Test that tilde in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest~") # 4.19μs -> 3.42μs (22.6% faster)

    def test_invalid_character_caret(self):
        """Test that caret in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest^") # 4.21μs -> 3.45μs (22.1% faster)

    def test_invalid_character_equal(self):
        """Test that equal sign in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest=") # 4.14μs -> 3.38μs (22.5% faster)

    def test_invalid_character_plus(self):
        """Test that plus in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest+") # 4.14μs -> 3.43μs (20.8% faster)

    def test_invalid_character_slash(self):
        """Test that forward slash in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest/") # 4.05μs -> 3.39μs (19.5% faster)

    def test_invalid_character_backslash(self):
        """Test that backslash in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest\\") # 4.36μs -> 3.31μs (31.8% faster)

    def test_invalid_character_question_mark(self):
        """Test that question mark in class name raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest?") # 4.25μs -> 3.52μs (20.8% faster)

    def test_comma_separated_with_invalid_second_pattern(self):
        """Test that invalid second pattern in comma-separated list raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest,9Invalid") # 5.31μs -> 4.29μs (23.8% faster)

    def test_comma_separated_with_invalid_middle_pattern(self):
        """Test that invalid middle pattern in comma-separated list raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest,9Invalid,OtherTest") # 5.22μs -> 4.17μs (25.2% faster)

    def test_comma_only_invalid(self):
        """Test that comma-only string raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter(",") # 3.82μs -> 3.15μs (21.3% faster)

    def test_double_comma_with_empty_pattern(self):
        """Test that double comma creates empty pattern which raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest,,OtherTest") # 5.10μs -> 4.16μs (22.7% faster)

    def test_leading_comma_creates_empty_pattern(self):
        """Test that leading comma creates empty pattern which raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter(",MyTest") # 3.87μs -> 3.06μs (26.6% faster)

    def test_trailing_comma_creates_empty_pattern(self):
        """Test that trailing comma creates empty pattern which raises ValueError."""
        with pytest.raises(ValueError):
            _validate_test_filter("MyTest,") # 4.96μs -> 3.94μs (26.0% faster)

    def test_very_long_valid_class_name(self):
        """Test with a very long but valid class name."""
        long_name = "com." + "a" * 100 + ".MyTest"
        codeflash_output = _validate_test_filter(long_name); result = codeflash_output # 3.21μs -> 2.37μs (35.6% faster)

    def test_multiple_dollar_signs(self):
        """Test with multiple dollar signs (nested inner classes)."""
        codeflash_output = _validate_test_filter("Outer$Middle$Inner"); result = codeflash_output # 3.02μs -> 2.11μs (42.7% faster)

    

To edit these changes git checkout codeflash/optimize-pr1199-2026-02-03T13.30.36 and push.

[KRRT7]

Closing stale bot PR.