⚡️ Speed up method AssertCleanup.transform_asserts by 46% 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.

---

📄 46% (0.46x) speedup for AssertCleanup.transform_asserts in codeflash/code_utils/concolic_utils.py

⏱️ Runtime : 842 microseconds → 576 microseconds (best of 751 runs)

📝 Explanation and details

Here is the optimized version of the given Python program. The program is optimized to run faster by pre-compiling regular expressions, avoiding repetitive function calls, and streamlining string manipulations.

Explanation of Optimizations

1. Pre-compiling Regular Expressions:

   • re.compile is used to pre-compile the regular expressions when the class is initialized, which speeds up the _transform_assert_line method by avoiding the need to compile the same patterns multiple times.

2. Avoiding Repetitive Function Calls.

   • The append method of lists is resolved once and assigned to a variable before entering the loop in _split_top_level_args. This avoids the cost of repeatedly resolving the method during each iteration of the loop.

3. Streamlined String Manipulations.

   • Instead of using strip and re.sub together, simplified rstrip with the specified characters is used to achieve the same effect with lesser overhead.

These changes contribute to small performance improvements, which can add up for larger codebases or more intensive usage scenarios.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 91 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 2 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.concolic_utils import AssertCleanup

# unit tests

def test_basic_assert_statements():
    # Test simple assert statements without equality checks
    code = "assert x\nassert my_var"
    expected = "x\nmy_var"
    codeflash_output = AssertCleanup().transform_asserts(code)

    # Test assert statements with equality checks
    code = "assert x == y\nassert my_var == 10"
    expected = "x\my_var"
    codeflash_output = AssertCleanup().transform_asserts(code)

def test_negated_assert_statements():
    # Test assert statements with negations
    code = "assert not x\nassert not my_var == 10"
    expected = "not x\nnot my_var == 10"
    codeflash_output = AssertCleanup().transform_asserts(code)

def test_complex_assert_statements():
    # Test assert statements with multiple conditions
    code = "assert x and y\nassert x or y"
    expected = "x and y\nx or y"
    codeflash_output = AssertCleanup().transform_asserts(code)

    # Test assert statements with function calls
    code = "assert is_valid(x)\nassert check(x, y)"
    expected = "is_valid(x)\ncheck(x, y)"
    codeflash_output = AssertCleanup().transform_asserts(code)

def test_unittest_assert_methods():
    # Test basic unittest assert methods
    code = "self.assertTrue(x)\nself.assertFalse(x)"
    expected = "x\nx"
    codeflash_output = AssertCleanup().transform_asserts(code)

    # Test unittest assert methods with multiple arguments
    code = "self.assertEqual(x, y)\nself.assertNotEqual(x, y)"
    expected = "x\ny\nx\ny"
    codeflash_output = AssertCleanup().transform_asserts(code)

def test_edge_cases():
    # Test empty lines
    code = ""
    expected = ""
    codeflash_output = AssertCleanup().transform_asserts(code)

    # Test lines with only whitespace
    code = "    "
    expected = "    "
    codeflash_output = AssertCleanup().transform_asserts(code)

    # Test lines with comments
    code = "# assert x\nassert x  # check x"
    expected = "# assert x\nx  # check x"
    codeflash_output = AssertCleanup().transform_asserts(code)

    # Test lines with non-assert statements
    code = "x = 10\nprint(x)"
    expected = "x = 10\nprint(x)"
    codeflash_output = AssertCleanup().transform_asserts(code)

def test_indentation_variations():
    # Test assert statements with different levels of indentation
    code = "    assert x\n        assert x"
    expected = "    x\n        x"
    codeflash_output = AssertCleanup().transform_asserts(code)

    # Test unittest assert methods with different levels of indentation
    code = "    self.assertTrue(x)\n        self.assertEqual(x, y)"
    expected = "    x\n        x\ny"
    codeflash_output = AssertCleanup().transform_asserts(code)

def test_large_scale_test_cases():
    # Test large blocks of code with multiple assert statements
    code = """
def test_function():
    assert x
    assert y == 10
    assert not z
    self.assertTrue(a)
    self.assertEqual(b, c)
"""
    expected = """
def test_function():
    x
    y
    not z
    a
    b
    c
"""
    codeflash_output = AssertCleanup().transform_asserts(code)

    # Test large blocks of code with mixed content
    code = """
def test_function():
    x = 10
    assert x
    print(x)
    assert y == 10
    # Comment
    assert not z
    self.assertTrue(a)
    self.assertEqual(b, c)
"""
    expected = """
def test_function():
    x = 10
    x
    print(x)
    y
    # Comment
    not z
    a
    b
    c
"""
    codeflash_output = AssertCleanup().transform_asserts(code)

def test_special_characters_and_symbols():
    # Test assert statements with special characters
    code = "assert x, y\nassert x; y"
    expected = "x, y\nx; y"
    codeflash_output = AssertCleanup().transform_asserts(code)

    # Test unittest assert methods with special characters
    code = "self.assertEqual(x, y,)\nself.assertEqual(x, y;)"
    expected = "x\ny\nx\ny"
    codeflash_output = AssertCleanup().transform_asserts(code)

def test_multi_line_statements():
    # Test assert statements split across multiple lines
    code = """
assert (
    x == y
)
"""
    expected = """
x
"""
    codeflash_output = AssertCleanup().transform_asserts(code)

    # Test unittest assert methods split across multiple lines
    code = """
self.assertEqual(
    x,
    y
)
"""
    expected = """
x
y
"""
    codeflash_output = AssertCleanup().transform_asserts(code)

def test_mixed_assert_methods():
    # Test mixed usage of different assert methods in a single block
    code = """
assert x
self.assertTrue(y)
assert not z
self.assertEqual(a, b)
"""
    expected = """
x
y
not z
a
b
"""
    codeflash_output = AssertCleanup().transform_asserts(code)

def test_invalid_or_malformed_statements():
    # Test malformed assert statements
    code = "assert\nassert =="
    expected = "assert\nassert =="
    codeflash_output = AssertCleanup().transform_asserts(code)

    # Test malformed unittest assert methods
    code = "self.assertTrue()\nself.assertEqual(x,)"
    expected = "self.assertTrue()\nx"
    codeflash_output = AssertCleanup().transform_asserts(code)
# 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.concolic_utils import AssertCleanup

# unit tests

def test_basic_assert_statements():
    ac = AssertCleanup()
    code = "assert x == 5\nassert y > 0\nassert z in list"
    expected = "x\nassert y > 0\nassert z in list"
    codeflash_output = ac.transform_asserts(code)

def test_assert_statements_with_not():
    ac = AssertCleanup()
    code = "assert not x == 5\nassert not y > 0\nassert not z in list"
    expected = "not x == 5\nnot y > 0\nnot z in list"
    codeflash_output = ac.transform_asserts(code)

def test_assert_statements_with_complex_expressions():
    ac = AssertCleanup()
    code = "assert (x + y) * z == 10\nassert (a and b) or (c and d)\nassert func(x) == expected_value"
    expected = "(x + y) * z\nassert (a and b) or (c and d)\nfunc(x)"
    codeflash_output = ac.transform_asserts(code)

def test_assert_statements_with_trailing_commas_or_semicolons():
    ac = AssertCleanup()
    code = "assert x == 5,\nassert y > 0;\nassert z in list,"
    expected = "x\nassert y > 0\nassert z in list"
    codeflash_output = ac.transform_asserts(code)

def test_self_assert_statements_from_unittest():
    ac = AssertCleanup()
    code = "self.assertEqual(x, 5)\nself.assertTrue(y > 0)\nself.assertIn(z, list)"
    expected = "x\nassert y > 0\nz"
    codeflash_output = ac.transform_asserts(code)

def test_self_assert_statements_with_multiple_arguments():
    ac = AssertCleanup()
    code = 'self.assertEqual(x, 5, "x should be 5")\nself.assertAlmostEqual(a, b, delta=0.01)\nself.assertRaises(ValueError, func, arg)'
    expected = "x\nassert a\nfunc"
    codeflash_output = ac.transform_asserts(code)

def test_self_assert_statements_with_complex_expressions():
    ac = AssertCleanup()
    code = "self.assertTrue((x + y) * z == 10)\nself.assertFalse((a and b) or (c and d))\nself.assertIsInstance(obj, MyClass)"
    expected = "(x + y) * z\nassert not (a and b) or (c and d)\nobj"
    codeflash_output = ac.transform_asserts(code)

def test_mixed_content():
    ac = AssertCleanup()
    code = "assert x == 5\n# this is a comment\nassert y > 0\n\nassert z in list\nif x > 0:\n    assert a == b"
    expected = "x\n# this is a comment\nassert y > 0\n\nassert z in list\nif x > 0:\n    a"
    codeflash_output = ac.transform_asserts(code)

def test_edge_cases():
    ac = AssertCleanup()
    codeflash_output = ac.transform_asserts("")
    codeflash_output = ac.transform_asserts("   ")
    codeflash_output = ac.transform_asserts("# this is a comment")
    codeflash_output = ac.transform_asserts("print('Hello, world!')")

def test_large_scale_test_cases():
    ac = AssertCleanup()
    code = "\n".join([f"assert x == {i}" for i in range(100)])
    expected = "\n".join(["x" for i in range(100)])
    codeflash_output = ac.transform_asserts(code)

    code = "\n".join([f"self.assertEqual(x, {i})" for i in range(100)])
    expected = "\n".join(["x" for i in range(100)])
    codeflash_output = ac.transform_asserts(code)

    code = "\n".join([f"assert x == {i}\nself.assertEqual(y, {i})" for i in range(50)])
    expected = "\n".join(["x\ny" for i in range(50)])
    codeflash_output = ac.transform_asserts(code)

if __name__ == "__main__":
    pytest.main()
# 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.concolic_utils import AssertCleanup

def test_AssertCleanup_transform_asserts():
    AssertCleanup.transform_asserts(AssertCleanup(), '\n')

To edit these changes git checkout codeflash/optimize-pr26-2025-02-27T02.40.10 and push.