⚡️ Speed up method AssertCleanup._transform_assert_line by 34% in PR #26 (clean_concolic_tests)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #26

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

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

---

📄 34% (0.34x) speedup for AssertCleanup._transform_assert_line in codeflash/code_utils/code_replacer.py

⏱️ Runtime : 220 microseconds → 164 microseconds (best of 439 runs)

📝 Explanation and details

To optimize the AssertCleanup class, we can improve the _transform_assert_line method by reducing the use of regular expressions, and replacing them with more efficient string operations where possible. Where regular expressions are still necessary, we compile them once and reuse them. Here's the refactored code.

Explanation of Changes.

1. Regex Compilation in __init__: Compiled the regular expressions in the __init__ method to avoid recompiling them every time _transform_assert_line is called, improving speed.

2. String Operations for Trailing Characters: Replaced re.sub used to strip trailing commas or semicolons with simpler string operations, improving efficiency.

These improvements help in optimizing the running speed of the program while maintaining the same functionality.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 66 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 6 Passed
📊 Tests Coverage	undefined

🌀 Generated Regression Tests Details

from __future__ import annotations

import re
from typing import Optional

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.code_replacer import AssertCleanup


# unit tests
@pytest.fixture
def assert_cleanup():
    return AssertCleanup()

def test_basic_assert_statements(assert_cleanup):
    # Simple assertion without comparison
    codeflash_output = assert_cleanup._transform_assert_line("assert x")
    codeflash_output = assert_cleanup._transform_assert_line("assert y > 0")
    
    # Assertion with comparison
    codeflash_output = assert_cleanup._transform_assert_line("assert x == 1")
    codeflash_output = assert_cleanup._transform_assert_line("assert y == 'test'")

def test_assert_statements_with_not(assert_cleanup):
    # Negated assertion
    codeflash_output = assert_cleanup._transform_assert_line("assert not x")
    codeflash_output = assert_cleanup._transform_assert_line("assert not (y > 0)")

def test_assert_statements_with_trailing_characters(assert_cleanup):
    # Assertion with trailing comma
    codeflash_output = assert_cleanup._transform_assert_line("assert x,")
    codeflash_output = assert_cleanup._transform_assert_line("assert y > 0,")
    
    # Assertion with trailing semicolon
    codeflash_output = assert_cleanup._transform_assert_line("assert x;")
    codeflash_output = assert_cleanup._transform_assert_line("assert y > 0;")

def test_unittest_assertions(assert_cleanup):
    # Basic unittest assertion
    codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual(x, 1)")
    codeflash_output = assert_cleanup._transform_assert_line("self.assertTrue(y > 0)")

    # Unittest assertion with multiple arguments
    codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual(x, 1, 'x should be 1')")
    codeflash_output = assert_cleanup._transform_assert_line("self.assertAlmostEqual(a, b, delta=0.1)")

def test_unittest_assertions_with_nested_arguments(assert_cleanup):
    # Nested arguments in unittest assertion
    codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual(func(x, y), 1)")
    codeflash_output = assert_cleanup._transform_assert_line("self.assertListEqual([a, b], [1, 2])")

def test_indentation_handling(assert_cleanup):
    # Different levels of indentation
    codeflash_output = assert_cleanup._transform_assert_line("    assert x")
    codeflash_output = assert_cleanup._transform_assert_line("        assert y > 0")
    codeflash_output = assert_cleanup._transform_assert_line("    self.assertEqual(x, 1)")
    codeflash_output = assert_cleanup._transform_assert_line("        self.assertTrue(y > 0)")

def test_edge_cases(assert_cleanup):
    # Empty line
    codeflash_output = assert_cleanup._transform_assert_line("")
    
    # Line with only whitespace
    codeflash_output = assert_cleanup._transform_assert_line("    ")
    
    # Line without assert or unittest assertion
    codeflash_output = assert_cleanup._transform_assert_line("print(x)")
    codeflash_output = assert_cleanup._transform_assert_line("x = 1")

def test_large_scale_test_cases(assert_cleanup):
    # Multiple assertions in a large block of code
    large_code_block = """
    assert x
    assert y > 0
    self.assertEqual(x, 1)
    self.assertTrue(y > 0)
    """
    lines = large_code_block.strip().split("\n")
    expected = ["x", "y > 0", "x", "y > 0"]
    result = [assert_cleanup._transform_assert_line(line) for line in lines]
    
    # Complex expressions within assertions
    codeflash_output = assert_cleanup._transform_assert_line("assert (x + y) * (a - b) == 0")
    codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual((func1(x) + func2(y)), expected_value)")

def test_invalid_or_malformed_lines(assert_cleanup):
    # Malformed assert statement
    codeflash_output = assert_cleanup._transform_assert_line("assert")
    codeflash_output = assert_cleanup._transform_assert_line("assert x ==")
    
    # Malformed unittest assertion
    codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual(x,)")
    codeflash_output = assert_cleanup._transform_assert_line("self.assertTrue(")

def test_performance_and_scalability(assert_cleanup):
    # Large number of assertions
    large_number_of_assertions = "\n".join([f"assert x == {i}" for i in range(1000)])
    lines = large_number_of_assertions.split("\n")
    expected = ["x" for _ in range(1000)]
    result = [assert_cleanup._transform_assert_line(line) for line in lines]
    
    # Complex nested structures
    complex_assertion = "assert ((x + y) * (a - b)) == 0"
    codeflash_output = assert_cleanup._transform_assert_line(complex_assertion)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from __future__ import annotations

import re
from typing import Optional

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.code_replacer import AssertCleanup


# unit tests
def test_basic_assert_statements():
    ac = AssertCleanup()
    # Simple assert statement
    codeflash_output = ac._transform_assert_line("assert x == y")
    # Complex expression
    codeflash_output = ac._transform_assert_line("assert (x + y) * z == w")
    # Trailing comma
    codeflash_output = ac._transform_assert_line("assert x == y,")
    # Trailing semicolon
    codeflash_output = ac._transform_assert_line("assert x == y;")

def test_assert_statements_with_not():
    ac = AssertCleanup()
    # Simple assert with not
    codeflash_output = ac._transform_assert_line("assert not x == y")
    # Complex assert with not
    codeflash_output = ac._transform_assert_line("assert not (x + y) * z == w")

def test_unittest_assertions():
    ac = AssertCleanup()
    # Simple unittest assertion
    codeflash_output = ac._transform_assert_line("self.assertEqual(x, y)")
    # Multiple arguments
    codeflash_output = ac._transform_assert_line('self.assertEqual(x, y, "message")')
    # Nested arguments
    codeflash_output = ac._transform_assert_line("self.assertEqual((x, y), (a, b))")

def test_edge_cases():
    ac = AssertCleanup()
    # Empty line
    codeflash_output = ac._transform_assert_line("")
    # Only whitespace
    codeflash_output = ac._transform_assert_line("    ")
    # Non-assert line
    codeflash_output = ac._transform_assert_line('print("Hello, World!")')
    # Malformed assert statement
    codeflash_output = ac._transform_assert_line("assert x ==")
    # Malformed unittest assertion
    codeflash_output = ac._transform_assert_line("self.assertEqual(x)")

def test_indentation_handling():
    ac = AssertCleanup()
    # Indented assert statement
    codeflash_output = ac._transform_assert_line("    assert x == y")
    # Indented unittest assertion
    codeflash_output = ac._transform_assert_line("    self.assertEqual(x, y)")

def test_large_scale_cases():
    ac = AssertCleanup()
    # Long assert statement
    codeflash_output = ac._transform_assert_line("assert x1 == y1 and x2 == y2 and x3 == y3 and x4 == y4 and x5 == y5")
    # Long unittest assertion
    codeflash_output = ac._transform_assert_line('self.assertEqual(x1, y1, "msg1", x2, y2, "msg2", x3, y3, "msg3")')

def test_complex_expressions():
    ac = AssertCleanup()
    # Assert with function calls
    codeflash_output = ac._transform_assert_line("assert func(x, y) == z")
    # Unittest with function calls
    codeflash_output = ac._transform_assert_line("self.assertEqual(func(x, y), z)")

def test_mixed_content():
    ac = AssertCleanup()
    # Assert with comments
    codeflash_output = ac._transform_assert_line("assert x == y  # Check if x equals y")
    # Unittest with comments
    codeflash_output = ac._transform_assert_line("self.assertEqual(x, y)  # Check if x equals y")
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from codeflash.code_utils.code_replacer import AssertCleanup

def test_AssertCleanup__transform_assert_line():
    AssertCleanup._transform_assert_line(AssertCleanup(), '\tself.assertA(\x00)')

def test_AssertCleanup__transform_assert_line_2():
    AssertCleanup._transform_assert_line(AssertCleanup(), 'assert\u2028')

def test_AssertCleanup__transform_assert_line_3():
    AssertCleanup._transform_assert_line(AssertCleanup(), '')

[KRRT7]

LGTM! thanks codeflash!