Clean concolic tests #26
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
![codeflash-ai[bot]](https://avatars.githubusercontent.com/in/413177?s=60&v=4){kind=small}
⚡️ Codeflash found optimizations for this PR📄 24% (0.24x) speedup for
|
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 82 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.code_replacer import AssertCleanup
# unit tests
def test_simple_assert_statements():
ac = AssertCleanup()
code = "assert x > 0\nassert is_valid"
expected = "x > 0\nis_valid"
codeflash_output = ac.transform_asserts(code)
def test_assert_statements_with_comparison():
ac = AssertCleanup()
code = "assert x == 0\nassert value == expected_value"
expected = "x\nvalue"
codeflash_output = ac.transform_asserts(code)
def test_assert_with_not():
ac = AssertCleanup()
code = "assert not x\nassert not is_valid"
expected = "not x\nnot is_valid"
codeflash_output = ac.transform_asserts(code)
def test_assert_with_trailing_characters():
ac = AssertCleanup()
code = "assert x > 0,\nassert is_valid;"
expected = "x > 0\nis_valid"
codeflash_output = ac.transform_asserts(code)
def test_unittest_assertions():
ac = AssertCleanup()
code = "self.assertTrue(x > 0)\nself.assertFalse(is_valid)"
expected = "x > 0\nis_valid"
codeflash_output = ac.transform_asserts(code)
def test_unittest_assertions_with_multiple_args():
ac = AssertCleanup()
code = "self.assertEqual(x, 0)\nself.assertNotEqual(value, expected_value)"
expected = "x\nvalue"
codeflash_output = ac.transform_asserts(code)
def test_indentation_handling():
ac = AssertCleanup()
code = " assert x > 0\n assert is_valid\n self.assertTrue(x > 0)\n self.assertEqual(x, 0)"
expected = " x > 0\n is_valid\n x > 0\n x"
codeflash_output = ac.transform_asserts(code)
def test_complex_expressions():
ac = AssertCleanup()
code = "assert (x > 0) and (y < 5)\nassert (is_valid and not is_empty)"
expected = "(x > 0) and (y < 5)\n(is_valid and not is_empty)"
codeflash_output = ac.transform_asserts(code)
def test_mixed_content_lines():
ac = AssertCleanup()
code = "assert x > 0 # Check if x is positive\nself.assertTrue(x > 0) # Ensure x is greater than zero"
expected = "x > 0 # Check if x is positive\nx > 0 # Ensure x is greater than zero"
codeflash_output = ac.transform_asserts(code)
def test_non_matching_lines():
ac = AssertCleanup()
code = "print(\"Hello, World!\")\nx = 10\nif x > 0:"
expected = "print(\"Hello, World!\")\nx = 10\nif x > 0:"
codeflash_output = ac.transform_asserts(code)
def test_empty_and_whitespace_lines():
ac = AssertCleanup()
code = "\n "
expected = "\n "
codeflash_output = ac.transform_asserts(code)
def test_large_scale():
ac = AssertCleanup()
code = "\n".join([f"assert x == {i}" for i in range(1000)])
expected = "\n".join(["x" for _ in range(1000)])
codeflash_output = ac.transform_asserts(code)
def test_edge_cases():
ac = AssertCleanup()
code = "assert\nassert x >"
expected = "assert\nassert x >"
codeflash_output = ac.transform_asserts(code)
def test_mixed_assert_and_unittest():
ac = AssertCleanup()
code = "assert x > 0\nself.assertTrue(is_valid)\nassert y == 5\nself.assertEqual(value, expected_value)"
expected = "x > 0\nis_valid\ny\nvalue"
codeflash_output = ac.transform_asserts(code)
def test_comments_and_docstrings():
ac = AssertCleanup()
code = "# This is a comment\nassert x > 0 # Check if x is positive\n\"\"\"\nThis is a docstring\n\"\"\"\nself.assertTrue(is_valid) # Ensure validity"
expected = "# This is a comment\nx > 0 # Check if x is positive\n\"\"\"\nThis is a docstring\n\"\"\"\nis_valid # Ensure validity"
codeflash_output = ac.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.code_replacer import AssertCleanup
# unit tests
def test_basic_assert():
ac = AssertCleanup()
code = "assert x"
expected = "x"
codeflash_output = ac.transform_asserts(code)
def test_assert_with_comparison():
ac = AssertCleanup()
code = "assert x == y"
expected = "x"
codeflash_output = ac.transform_asserts(code)
def test_assert_with_logical_expression():
ac = AssertCleanup()
code = "assert x and y"
expected = "x and y"
codeflash_output = ac.transform_asserts(code)
def test_assert_with_trailing_comma():
ac = AssertCleanup()
code = "assert x,"
expected = "x"
codeflash_output = ac.transform_asserts(code)
def test_assert_with_trailing_semicolon():
ac = AssertCleanup()
code = "assert x;"
expected = "x"
codeflash_output = ac.transform_asserts(code)
def test_assert_with_indentation():
ac = AssertCleanup()
code = " assert x"
expected = " x"
codeflash_output = ac.transform_asserts(code)
def test_assert_in_function():
ac = AssertCleanup()
code = """def test():
assert x"""
expected = """def test():
x"""
codeflash_output = ac.transform_asserts(code)
def test_assert_in_class_method():
ac = AssertCleanup()
code = """class Test:
def test_method(self):
assert x"""
expected = """class Test:
def test_method(self):
x"""
codeflash_output = ac.transform_asserts(code)
def test_assert_with_not():
ac = AssertCleanup()
code = "assert not x"
expected = "not x"
codeflash_output = ac.transform_asserts(code)
def test_assert_with_not_and_comparison():
ac = AssertCleanup()
code = "assert not x == y"
expected = "not x == y"
codeflash_output = ac.transform_asserts(code)
def test_self_assert_true():
ac = AssertCleanup()
code = "self.assertTrue(x)"
expected = "x"
codeflash_output = ac.transform_asserts(code)
def test_self_assert_equal():
ac = AssertCleanup()
code = "self.assertEqual(x, y)"
expected = "x"
codeflash_output = ac.transform_asserts(code)
def test_self_assert_in():
ac = AssertCleanup()
code = "self.assertIn(x, y)"
expected = "x"
codeflash_output = ac.transform_asserts(code)
def test_self_assert_in_function():
ac = AssertCleanup()
code = """def test():
self.assertTrue(x)"""
expected = """def test():
x"""
codeflash_output = ac.transform_asserts(code)
def test_self_assert_in_class_method():
ac = AssertCleanup()
code = """class Test:
def test_method(self):
self.assertTrue(x)"""
expected = """class Test:
def test_method(self):
x"""
codeflash_output = ac.transform_asserts(code)
def test_assert_with_complex_expression():
ac = AssertCleanup()
code = "assert (x and y) or z"
expected = "(x and y) or z"
codeflash_output = ac.transform_asserts(code)
def test_self_assert_with_complex_expression():
ac = AssertCleanup()
code = "self.assertTrue((x and y) or z)"
expected = "(x and y) or z"
codeflash_output = ac.transform_asserts(code)
def test_empty_line():
ac = AssertCleanup()
code = ""
expected = ""
codeflash_output = ac.transform_asserts(code)
def test_whitespace_line():
ac = AssertCleanup()
code = " "
expected = " "
codeflash_output = ac.transform_asserts(code)
def test_comment_line():
ac = AssertCleanup()
code = "# This is a comment"
expected = "# This is a comment"
codeflash_output = ac.transform_asserts(code)
def test_assert_with_comment():
ac = AssertCleanup()
code = "assert x # This is a comment"
expected = "x # This is a comment"
codeflash_output = ac.transform_asserts(code)
def test_self_assert_with_comment():
ac = AssertCleanup()
code = "self.assertTrue(x) # This is a comment"
expected = "x # This is a comment"
codeflash_output = ac.transform_asserts(code)
def test_non_assert_line():
ac = AssertCleanup()
code = "print(x)"
expected = "print(x)"
codeflash_output = ac.transform_asserts(code)
def test_syntax_error_line():
ac = AssertCleanup()
code = "assert x == "
expected = "assert x == "
codeflash_output = ac.transform_asserts(code)
def test_large_code_block():
ac = AssertCleanup()
code = """def test():
assert x
assert y
assert z == 1
self.assertTrue(a)
self.assertEqual(b, c)"""
expected = """def test():
x
y
z
a
b"""
codeflash_output = ac.transform_asserts(code)
def test_large_codebase():
ac = AssertCleanup()
code = """class Test:
def test_method(self):
assert x
self.assertTrue(y)
self.assertEqual(z, 1)
print("Hello, World!")
assert not a
self.assertIn(b, c)"""
expected = """class Test:
def test_method(self):
x
y
z
print("Hello, World!")
not a
b"""
codeflash_output = ac.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 codeflash.code_utils.code_replacer import AssertCleanup
def test_AssertCleanup_transform_asserts():
AssertCleanup.transform_asserts(AssertCleanup(), '\n')
codeflash-ai bot
added a commit
that referenced
this pull request
Feb 25, 2025
…#26 (`clean_concolic_tests`) 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.
⚡️ Codeflash found optimizations for this PR📄 34% (0.34x) speedup for
|
Co-authored-by: codeflash-ai[bot] <148906541+codeflash-ai[bot]@users.noreply.github.com>
|
This PR is now faster! 🚀 Kevin Turcios accepted my code suggestion above. |
This reverts commit 04fc3e6.
codeflash-ai bot
added a commit
that referenced
this pull request
Feb 25, 2025
…(`clean_concolic_tests`) To optimize the given code, we should focus on reducing redundant operations and improving the performance of regular expression matching, string manipulation, and list operations. Let's break down the changes. ### Key Optimizations. This results in a more efficient and potentially faster code execution while maintaining the same functionality and output structure.
⚡️ Codeflash found optimizations for this PR📄 82% (0.82x) speedup for
|
⚡️ Codeflash found optimizations for this PR📄 44% (0.44x) speedup for
|
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 2104 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(assert_cleanup):
# Simple assert statements
codeflash_output = assert_cleanup._transform_assert_line("assert x == y")
codeflash_output = assert_cleanup._transform_assert_line("assert a > b")
def test_assert_with_not(assert_cleanup):
# Assert statements with 'not'
codeflash_output = assert_cleanup._transform_assert_line("assert not x")
codeflash_output = assert_cleanup._transform_assert_line("assert not (a == b)")
def test_complex_expressions(assert_cleanup):
# Assert statements with complex expressions
codeflash_output = assert_cleanup._transform_assert_line("assert x > y and y > z")
codeflash_output = assert_cleanup._transform_assert_line("assert (a + b) == (c - d)")
def test_expressions_with_function_calls(assert_cleanup):
# Assert statements with function calls
codeflash_output = assert_cleanup._transform_assert_line("assert func(x) == 10")
codeflash_output = assert_cleanup._transform_assert_line("assert is_valid(a, b)")
def test_trailing_characters(assert_cleanup):
# Assert statements with trailing comma or semicolon
codeflash_output = assert_cleanup._transform_assert_line("assert x == y,")
codeflash_output = assert_cleanup._transform_assert_line("assert a > b,")
codeflash_output = assert_cleanup._transform_assert_line("assert x == y;")
codeflash_output = assert_cleanup._transform_assert_line("assert a > b;")
def test_unittest_assertions(assert_cleanup):
# Basic unittest assertions
codeflash_output = assert_cleanup._transform_assert_line(" self.assertEqual(x, y)")
codeflash_output = assert_cleanup._transform_assert_line(" self.assertTrue(condition)")
def test_unittest_with_multiple_arguments(assert_cleanup):
# Unittest assertions with multiple arguments
codeflash_output = assert_cleanup._transform_assert_line(" self.assertAlmostEqual(a, b, delta=0.01)")
codeflash_output = assert_cleanup._transform_assert_line(" self.assertIn(item, collection)")
def test_unittest_with_complex_arguments(assert_cleanup):
# Unittest assertions with complex arguments
codeflash_output = assert_cleanup._transform_assert_line(" self.assertDictEqual({'a': 1}, {'a': 1})")
codeflash_output = assert_cleanup._transform_assert_line(" self.assertListEqual([1, 2], [1, 2])")
def test_unittest_with_function_calls(assert_cleanup):
# Unittest assertions with function calls within arguments
codeflash_output = assert_cleanup._transform_assert_line(" self.assertGreater(func(x), 10)")
codeflash_output = assert_cleanup._transform_assert_line(" self.assertIsNone(get_value())")
def test_edge_cases(assert_cleanup):
# Edge cases
codeflash_output = assert_cleanup._transform_assert_line("")
codeflash_output = assert_cleanup._transform_assert_line(" ")
codeflash_output = assert_cleanup._transform_assert_line("print('Hello World')")
codeflash_output = assert_cleanup._transform_assert_line("x = 10")
codeflash_output = assert_cleanup._transform_assert_line("assert")
codeflash_output = assert_cleanup._transform_assert_line("assert x ==")
codeflash_output = assert_cleanup._transform_assert_line(" self.assertTrue()")
codeflash_output = assert_cleanup._transform_assert_line(" self.assertFalse()")
def test_large_scale(assert_cleanup):
# Large scale test cases
codeflash_output = assert_cleanup._transform_assert_line("assert (a + b + c + d + e + f + g + h + i + j) == (k + l + m + n + o + p + q + r + s + t)")
codeflash_output = assert_cleanup._transform_assert_line("assert x == y\nassert a > b\nassert func(c) == d")
def test_performance_and_scalability(assert_cleanup):
# Performance and scalability
codeflash_output = assert_cleanup._transform_assert_line(" self.assertEqual(a, b, c, d, e, f, g, h, i, j)")
codeflash_output = assert_cleanup._transform_assert_line(" self.assertDictEqual({'a': {'b': {'c': 1}}}, {'a': {'b': {'c': 1}}})")
# 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
@pytest.fixture
def assert_cleanup():
return AssertCleanup()
# Basic Assert Statements
def test_simple_assert_statements(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert x == 1")
codeflash_output = assert_cleanup._transform_assert_line("assert y != 2")
def test_assert_statements_with_logical_operators(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert x > 1 and y < 2")
codeflash_output = assert_cleanup._transform_assert_line("assert a or b")
# Assert Statements with Negation
def test_negated_assert_statements(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert not x")
codeflash_output = assert_cleanup._transform_assert_line("assert not (x == 1)")
# Assert Statements with Trailing Characters
def test_assert_statements_with_trailing_characters(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert x == 1,")
codeflash_output = assert_cleanup._transform_assert_line("assert y != 2;")
# Unittest Assertion Methods
def test_basic_unittest_assertions(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual(x, 1)")
codeflash_output = assert_cleanup._transform_assert_line("self.assertTrue(x)")
codeflash_output = assert_cleanup._transform_assert_line("self.assertFalse(y)")
def test_unittest_assertions_with_multiple_arguments(assert_cleanup):
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)")
# Complex Expressions
def test_assert_statements_with_complex_expressions(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert (x == 1 and y != 2)")
codeflash_output = assert_cleanup._transform_assert_line("assert (a or b) and not c")
def test_unittest_assertions_with_complex_expressions(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("self.assertTrue((x == 1 and y != 2))")
codeflash_output = assert_cleanup._transform_assert_line("self.assertFalse((a or b) and not c)")
# Nested Structures
def test_assert_statements_with_nested_structures(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert [1, 2, 3] == [1, 2, 3]")
codeflash_output = assert_cleanup._transform_assert_line('assert {"key": "value"} == {"key": "value"}')
# Handling Indentation
def test_indented_assert_statements(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line(" assert x == 1")
codeflash_output = assert_cleanup._transform_assert_line(" assert y != 2")
def test_indented_unittest_assertions(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line(" self.assertEqual(x, 1)")
codeflash_output = assert_cleanup._transform_assert_line(" self.assertTrue(x)")
# Edge Cases
def test_empty_or_whitespace_lines(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("")
codeflash_output = assert_cleanup._transform_assert_line(" ")
def test_invalid_assert_statements(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert")
codeflash_output = assert_cleanup._transform_assert_line("assert x ==")
def test_malformed_unittest_assertions(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual()")
codeflash_output = assert_cleanup._transform_assert_line("self.assertTrue")
# Large Scale Test Cases
def test_large_input_strings(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert " + "x == 1 and " * 1000 + "x == 1")
codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual(" + "x, 1, " * 1000 + '"x should be 1")')
# Performance and Scalability
def test_performance_with_many_assertions(assert_cleanup):
for i in range(1000):
codeflash_output = assert_cleanup._transform_assert_line(f"assert x == {i}")
def test_performance_with_many_unittest_assertions(assert_cleanup):
for i in range(1000):
codeflash_output = assert_cleanup._transform_assert_line(f"self.assertEqual(x, {i})")
# Complex Nested Assertions
def test_deeply_nested_assertions(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert ((x == 1) and (y != 2) and (z > 0))")
codeflash_output = assert_cleanup._transform_assert_line("self.assertTrue(((a or b) and (not c)))")
# Special Characters
def test_assertions_with_special_characters(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line('assert "string with special characters !@#$%^&*()"')
codeflash_output = assert_cleanup._transform_assert_line('self.assertEqual("special chars !@#$%^&*()", "special chars !@#$%^&*()")')
# Comments and String Literals
def test_assertions_with_comments(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert x == 1 # this is a comment")
codeflash_output = assert_cleanup._transform_assert_line("self.assertTrue(x) # another comment")
def test_assertions_with_string_literals(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line('assert "string, with, commas"')
codeflash_output = assert_cleanup._transform_assert_line('self.assertEqual("string; with; semicolons", "string; with; semicolons")')
# 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(), '')
⚡️ Codeflash found optimizations for this PR📄 28% (0.28x) speedup for
|
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 60 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.code_replacer import AssertCleanup
# unit tests
# Initialize the class
cleanup = AssertCleanup()
def test_basic_assert():
# Simple assert statement
codeflash_output = cleanup.transform_asserts("assert x == 1")
# Assert with a complex expression
codeflash_output = cleanup.transform_asserts("assert (x + y) * z == 42")
# Assert with a message
codeflash_output = cleanup.transform_asserts('assert x == 1, "x should be 1"')
def test_not_assert():
# Simple not expression
codeflash_output = cleanup.transform_asserts("assert not x")
# Complex not expression
codeflash_output = cleanup.transform_asserts("assert not (x and y)")
def test_unittest_asserts():
# Simple assertEqual
codeflash_output = cleanup.transform_asserts("self.assertEqual(x, 1)")
# AssertTrue with a complex expression
codeflash_output = cleanup.transform_asserts("self.assertTrue(x > 1 and y < 2)")
# AssertFalse with a not expression
codeflash_output = cleanup.transform_asserts("self.assertFalse(not x)")
def test_indentation():
# Indented assert statement
codeflash_output = cleanup.transform_asserts(" assert x == 1")
# Indented not expression
codeflash_output = cleanup.transform_asserts(" assert not x")
# Indented self.assertEqual
codeflash_output = cleanup.transform_asserts(" self.assertEqual(x, 1)")
def test_trailing_characters():
# Assert with trailing comma
codeflash_output = cleanup.transform_asserts("assert x == 1,")
# Assert with trailing semicolon
codeflash_output = cleanup.transform_asserts("assert x == 1;")
def test_non_assert_statements():
# Regular code line
codeflash_output = cleanup.transform_asserts("x = 1")
# Comment line
codeflash_output = cleanup.transform_asserts("# This is a comment")
def test_edge_cases():
# Empty line
codeflash_output = cleanup.transform_asserts("")
# Whitespace only line
codeflash_output = cleanup.transform_asserts(" ")
# Malformed assert statement
codeflash_output = cleanup.transform_asserts("assert")
# Malformed self.assert statement
codeflash_output = cleanup.transform_asserts("self.assertEqual()")
def test_large_scale():
# Large block of code with multiple asserts
input_code = "\n".join([
"assert x == 1",
"x = 2",
"self.assertTrue(x > 1 and y < 2)",
"assert not z",
"self.assertEqual(a, b)",
"# This is a comment"
])
expected_output = "\n".join([
"x",
"x = 2",
"x > 1 and y < 2",
"not z",
"a",
"# This is a comment"
])
codeflash_output = cleanup.transform_asserts(input_code)
def test_complex_expressions():
# Assert with multiple arguments
codeflash_output = cleanup.transform_asserts('self.assertEqual(x, y, "x should equal y")')
# Assert with nested function calls
codeflash_output = cleanup.transform_asserts("self.assertTrue(foo(bar(x), y))")
def test_mixed_content():
# Mixed content with comments and asserts
input_code = "\n".join([
"# Check if x is 1",
'assert x == 1, "x should be 1"',
"# Check if y is not None",
"assert y is not None"
])
expected_output = "\n".join([
"# Check if x is 1",
"x",
"# Check if y is not None",
"y is not None"
])
codeflash_output = cleanup.transform_asserts(input_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.code_replacer import AssertCleanup
# unit tests
def test_basic_assert_statements():
ac = AssertCleanup()
codeflash_output = ac.transform_asserts("assert x")
codeflash_output = ac.transform_asserts("assert x == y")
codeflash_output = ac.transform_asserts("assert x and y")
def test_assert_with_not():
ac = AssertCleanup()
codeflash_output = ac.transform_asserts("assert not x")
codeflash_output = ac.transform_asserts("assert not x == y")
def test_assert_with_trailing_characters():
ac = AssertCleanup()
codeflash_output = ac.transform_asserts("assert x,")
codeflash_output = ac.transform_asserts("assert x;")
def test_unittest_assertions():
ac = AssertCleanup()
codeflash_output = ac.transform_asserts("self.assertEqual(x, y)")
codeflash_output = ac.transform_asserts('self.assertTrue(x, "message")')
codeflash_output = ac.transform_asserts("self.assertTrue()")
def test_indentation_handling():
ac = AssertCleanup()
codeflash_output = ac.transform_asserts(" assert x")
codeflash_output = ac.transform_asserts(" self.assertEqual(x, y)")
def test_mixed_content():
ac = AssertCleanup()
codeflash_output = ac.transform_asserts("if condition: assert x")
codeflash_output = ac.transform_asserts("if condition: self.assertEqual(x, y)")
def test_lines_that_should_not_change():
ac = AssertCleanup()
codeflash_output = ac.transform_asserts("x = 1")
codeflash_output = ac.transform_asserts("# assert x")
codeflash_output = ac.transform_asserts("")
def test_edge_cases():
ac = AssertCleanup()
codeflash_output = ac.transform_asserts("")
codeflash_output = ac.transform_asserts(" ")
codeflash_output = ac.transform_asserts("assert")
codeflash_output = ac.transform_asserts("self.assertEqual")
def test_complex_expressions():
ac = AssertCleanup()
codeflash_output = ac.transform_asserts("assert (x and\ny)")
codeflash_output = ac.transform_asserts("self.assertEqual(\nx, y)")
def test_large_scale():
ac = AssertCleanup()
large_code = "\n".join([f"assert x{i} == y{i}" for i in range(1000)])
expected_output = "\n".join([f"x{i}" for i in range(1000)])
codeflash_output = ac.transform_asserts(large_code)
def test_special_characters_in_assertions():
ac = AssertCleanup()
codeflash_output = ac.transform_asserts('assert x == "hello, world!"')
codeflash_output = ac.transform_asserts('self.assertEqual(x, "hello, world!")')
# Run the tests
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.code_replacer import AssertCleanup
def test_AssertCleanup_transform_asserts():
AssertCleanup.transform_asserts(AssertCleanup(), '\n')
KRRT7
force-pushed
the
clean_concolic_tests
branch
from
1c0a643 to
1aadc0b
Compare
KRRT7
force-pushed
the
clean_concolic_tests
branch
from
1aadc0b to
8879e2e
Compare
⚡️ Codeflash found optimizations for this PR📄 22% (0.22x) speedup for
|
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | ✅ 39 Passed |
| 🌀 Generated Regression Tests | ✅ 51 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | undefined |
⚙️ Existing Unit Tests Details
- codeflash_concolic_o06e69oz/tmpl1g1lcio/test_concolic_coverage.py
- test_code_utils.py🌀 Generated Regression Tests Details
from __future__ import annotations
import ast
import re
from typing import Optional
# imports
import pytest # used for our unit tests
from codeflash.code_utils.code_replacer import clean_concolic_tests
# unit tests
# Basic Functionality
def test_basic_assert():
code = "def test_func():\n assert x == 1"
expected = "def test_func():\n assert x == 1"
codeflash_output = clean_concolic_tests(code)
def test_basic_self_assert():
code = "def test_func():\n self.assertTrue(x)"
expected = "def test_func():\n x"
codeflash_output = clean_concolic_tests(code)
# Edge Cases
def test_empty_input():
code = ""
expected = ""
codeflash_output = clean_concolic_tests(code)
def test_comments_and_whitespace():
code = " # This is a comment\n\n"
expected = " # This is a comment\n\n"
codeflash_output = clean_concolic_tests(code)
def test_non_test_function():
code = "def helper_function():\n pass"
expected = "def helper_function():\n pass"
codeflash_output = clean_concolic_tests(code)
# Syntax Errors
def test_unclosed_parentheses():
code = "def test_syntax_error():\n assert (x == 1"
expected = "def test_syntax_error():\n assert (x == 1"
codeflash_output = clean_concolic_tests(code)
def test_invalid_syntax():
code = "def test_invalid_syntax():\n assert x =="
expected = "def test_invalid_syntax():\n assert x =="
codeflash_output = clean_concolic_tests(code)
# Complex `assert` Statements
def test_nested_assertions():
code = "def test_func():\n assert (x == 1) and (y == 2)"
expected = "def test_func():\n assert (x == 1) and (y == 2)"
codeflash_output = clean_concolic_tests(code)
def test_assert_with_function_call():
code = "def test_func():\n assert func(x) == 1"
expected = "def test_func():\n func(x)"
codeflash_output = clean_concolic_tests(code)
def test_assert_with_not():
code = "def test_func():\n assert not x == 1"
expected = "def test_func():\n not x == 1"
codeflash_output = clean_concolic_tests(code)
# Complex `self.assert...` Statements
def test_self_assert_multiple_args():
code = "def test_func():\n self.assertEqual(x, y, 'message')"
expected = "def test_func():\n x"
codeflash_output = clean_concolic_tests(code)
def test_self_assert_nested_function_call():
code = "def test_func():\n self.assertTrue(func(x))"
expected = "def test_func():\n func(x)"
codeflash_output = clean_concolic_tests(code)
def test_self_assert_with_keyword_args():
code = "def test_func():\n self.assertAlmostEqual(x, y, delta=0.1)"
expected = "def test_func():\n x"
codeflash_output = clean_concolic_tests(code)
# Large Scale Test Cases
def test_large_number_of_test_functions():
code = "\n".join([f"def test_func_{i}():\n assert x == {i}" for i in range(100)])
expected = "\n".join([f"def test_func_{i}():\n assert x == {i}" for i in range(100)])
codeflash_output = clean_concolic_tests(code)
def test_large_body_of_single_test_function():
code = "def test_func():\n" + "\n".join([f" assert x == {i}" for i in range(100)])
expected = "def test_func():\n" + "\n".join([f" assert x == {i}" for i in range(100)])
codeflash_output = clean_concolic_tests(code)
# Mixed Content
def test_mixed_assert_and_self_assert():
code = "def test_func():\n assert x == 1\n self.assertEqual(y, 2)"
expected = "def test_func():\n assert x == 1\n y"
codeflash_output = clean_concolic_tests(code)
def test_mixed_test_and_non_test_functions():
code = "def test_func():\n assert x == 1\ndef helper():\n pass"
expected = "def test_func():\n assert x == 1\ndef helper():\n pass"
codeflash_output = clean_concolic_tests(code)
# Special Characters and Strings
def test_assert_with_strings():
code = "def test_func():\n assert 'hello' in greeting"
expected = "def test_func():\n assert 'hello' in greeting"
codeflash_output = clean_concolic_tests(code)
def test_assert_with_special_characters():
code = "def test_func():\n assert re.match(r'\\d+', text)"
expected = "def test_func():\n assert re.match(r'\\d+', text)"
codeflash_output = clean_concolic_tests(code)
# Indentation Variations
def test_different_levels_of_indentation():
code = "def test_func():\n assert x == 1\n assert y == 2"
expected = "def test_func():\n assert x == 1\n assert y == 2"
codeflash_output = clean_concolic_tests(code)
# Nested Structures
def test_assertions_within_loops():
code = "def test_func():\n for i in range(10):\n assert i < 10"
expected = "def test_func():\n for i in range(10):\n assert i < 10"
codeflash_output = clean_concolic_tests(code)
def test_assertions_within_conditionals():
code = "def test_func():\n if x:\n assert y == 2"
expected = "def test_func():\n if x:\n assert y == 2"
codeflash_output = clean_concolic_tests(code)
# Assertions with Comments
def test_inline_comments():
code = "def test_func():\n assert x == 1 # Check if x is 1"
expected = "def test_func():\n assert x == 1 # Check if x is 1"
codeflash_output = clean_concolic_tests(code)
def test_block_comments():
code = "# This is a test\ndef test_func():\n assert y == 2"
expected = "# This is a test\ndef test_func():\n assert y == 2"
codeflash_output = clean_concolic_tests(code)
# Assertions with Trailing Characters
def test_assert_with_trailing_comma():
code = "def test_func():\n assert x == 1,"
expected = "def test_func():\n assert x == 1"
codeflash_output = clean_concolic_tests(code)
def test_assert_with_trailing_semicolon():
code = "def test_func():\n assert y == 2;"
expected = "def test_func():\n assert y == 2"
codeflash_output = clean_concolic_tests(code)
# Function Calls in Assertions
def test_function_call_with_arguments():
code = "def test_func():\n assert func(x, y) == 1"
expected = "def test_func():\n func(x, y)"
codeflash_output = clean_concolic_tests(code)
def test_function_call_with_keyword_arguments():
code = "def test_func():\n assert func(a=x, b=y) == 1"
expected = "def test_func():\n func(a=x, b=y)"
codeflash_output = clean_concolic_tests(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 ast
import re
from typing import Optional
# imports
import pytest # used for our unit tests
from codeflash.code_utils.code_replacer import clean_concolic_tests
# unit tests
def test_basic_assert_statements():
# Test simple assert statements
input_code = "def test_func():\n assert x == 1\n assert y"
expected_output = "def test_func():\n assert x == 1\n assert y"
codeflash_output = clean_concolic_tests(input_code)
def test_basic_self_assert_statements():
# Test simple self.assert* statements
input_code = "def test_func():\n self.assertEqual(x, 1)\n self.assertTrue(y)"
expected_output = "def test_func():\n x\n y"
codeflash_output = clean_concolic_tests(input_code)
def test_empty_input():
# Test empty input
input_code = ""
expected_output = ""
codeflash_output = clean_concolic_tests(input_code)
def test_whitespace_only_input():
# Test whitespace-only input
input_code = " "
expected_output = " "
codeflash_output = clean_concolic_tests(input_code)
def test_single_line_comment():
# Test single-line comments
input_code = "# This is a comment"
expected_output = "# This is a comment"
codeflash_output = clean_concolic_tests(input_code)
def test_multi_line_comment():
# Test multi-line comments
input_code = '"""\n# This is a comment\n# Spanning multiple lines\n"""'
expected_output = '"""\n# This is a comment\n# Spanning multiple lines\n"""'
codeflash_output = clean_concolic_tests(input_code)
def test_invalid_python_code():
# Test invalid Python code
input_code = "assert x =="
expected_output = "assert x =="
codeflash_output = clean_concolic_tests(input_code)
def test_unclosed_string():
# Test unclosed strings
input_code = 'assert x == "hello'
expected_output = 'assert x == "hello'
codeflash_output = clean_concolic_tests(input_code)
def test_incorrect_indentation():
# Test incorrect indentation
input_code = "def test_func():\nassert x == 1"
expected_output = "def test_func():\nassert x == 1"
codeflash_output = clean_concolic_tests(input_code)
def test_nested_assert_statements():
# Test nested assert statements
input_code = "def test_func():\n assert (x == 1) and (y == 2)"
expected_output = "def test_func():\n assert (x == 1) and (y == 2)"
codeflash_output = clean_concolic_tests(input_code)
def test_assert_with_function_call():
# Test assert statements with function calls
input_code = "def test_func():\n assert func(x) == 1"
expected_output = "def test_func():\n func(x)"
codeflash_output = clean_concolic_tests(input_code)
def test_assert_with_not():
# Test assert statements with not
input_code = "def test_func():\n assert not x"
expected_output = "def test_func():\n assert not x"
codeflash_output = clean_concolic_tests(input_code)
def test_assert_with_trailing_comma():
# Test assert statements with trailing commas
input_code = "def test_func():\n assert x == 1,"
expected_output = "def test_func():\n assert x == 1"
codeflash_output = clean_concolic_tests(input_code)
def test_assert_with_trailing_semicolon():
# Test assert statements with trailing semicolons
input_code = "def test_func():\n assert x == 1;"
expected_output = "def test_func():\n assert x == 1"
codeflash_output = clean_concolic_tests(input_code)
def test_self_assert_with_multiple_arguments():
# Test self.assert* statements with multiple arguments
input_code = "def test_func():\n self.assertEqual(x, y, 'message')"
expected_output = "def test_func():\n x"
codeflash_output = clean_concolic_tests(input_code)
def test_self_assert_with_function_call():
# Test self.assert* statements with function calls
input_code = "def test_func():\n self.assertTrue(func(x))"
expected_output = "def test_func():\n func(x)"
codeflash_output = clean_concolic_tests(input_code)
def test_self_assert_with_nested_expression():
# Test self.assert* statements with nested expressions
input_code = "def test_func():\n self.assertEqual((x + y), 1)"
expected_output = "def test_func():\n (x + y)"
codeflash_output = clean_concolic_tests(input_code)
def test_large_test_suite():
# Test large input with many lines
input_code = "\n".join([f"def test_func{i}():\n assert x == {i}" for i in range(100)])
expected_output = "\n".join([f"def test_func{i}():\n assert x == {i}" for i in range(100)])
codeflash_output = clean_concolic_tests(input_code)
def test_mixed_assert_statements():
# Test mix of assert and self.assert* statements
input_code = "def test_func():\n assert x == 1\n self.assertTrue(y)"
expected_output = "def test_func():\n assert x == 1\n y"
codeflash_output = clean_concolic_tests(input_code)
def test_mixed_valid_invalid_statements():
# Test mix of valid and invalid statements
input_code = "def test_func():\n assert x == 1\n assert y ==\ndef test_func2():\n self.assertEqual(x, 1)"
expected_output = "def test_func():\n assert x == 1\n assert y ==\ndef test_func2():\n x"
codeflash_output = clean_concolic_tests(input_code)
def test_deterministic_behavior():
# Test consistent output for the same input
input_code = "def test_func():\n assert x == 1"
expected_output = "def test_func():\n assert x == 1"
codeflash_output = clean_concolic_tests(input_code)
codeflash_output = clean_concolic_tests(input_code) # Run twice to ensure consistency
def test_real_world_test_suite():
# Test integration with real-world test suites
input_code = """
def test_addition():
assert add(1, 2) == 3
self.assertEqual(add(2, 2), 4)
def test_subtraction():
assert subtract(2, 1) == 1
self.assertTrue(subtract(2, 1) == 1)
"""
expected_output = """
def test_addition():
add(1, 2)
add(2, 2)
def test_subtraction():
assert subtract(2, 1) == 1
subtract(2, 1)
"""
codeflash_output = clean_concolic_tests(input_code.strip())
# 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 clean_concolic_tests
import pytest
def test_clean_concolic_tests():
with pytest.raises(TypeError, match='compile\\(\\)\\ arg\\ 1\\ must\\ be\\ a\\ string,\\ bytes\\ or\\ AST\\ object'):
clean_concolic_tests('')
Comment on lines
384
to
388
| for char in args_str: | ||
| if char in "([{": | ||
| depth += 1 | ||
| current.append(char) | ||
| elif char in ")]}": |
There was a problem hiding this comment.
Suggested change
| for char in args_str: | |
| if char in "([{": | |
| depth += 1 | |
| current.append(char) | |
| elif char in ")]}": | |
| char_to_depth_change = {"(": 1, "[": 1, "{": 1, ")": -1, "]": -1, "}": -1} | |
| if char in char_to_depth_change: | |
| depth += char_to_depth_change[char] |
⚡️ Codeflash found optimizations for this PR📄 21% (0.21x) speedup for
|
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 68 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | ✅ 2 Passed |
| 📊 Tests Coverage | undefined |
🌀 Generated Regression Tests Details
from __future__ import annotations
# imports
import pytest # used for our unit tests
from codeflash.code_utils.code_replacer import AssertCleanup
# unit tests
def test_basic_single_argument():
# Single argument
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("arg1")
def test_basic_multiple_arguments():
# Multiple arguments
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("arg1,arg2,arg3")
def test_whitespace_handling():
# Leading and trailing whitespace
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args(" arg1 , arg2 ")
# Extra spaces between arguments
codeflash_output = ac._split_top_level_args("arg1 , arg2 , arg3")
def test_nested_structures_single_level():
# Single level nesting
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("func(arg1, arg2), arg3")
codeflash_output = ac._split_top_level_args("[1, 2, 3], 4")
def test_nested_structures_multiple_levels():
# Multiple levels of nesting
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("func1(func2(arg1, arg2), arg3), arg4")
codeflash_output = ac._split_top_level_args("{a: [1, 2, 3], b: 4}, 5")
def test_empty_and_special_cases():
# Empty string
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("")
# Single comma
codeflash_output = ac._split_top_level_args(",")
# Only whitespace
codeflash_output = ac._split_top_level_args(" ")
def test_mismatched_brackets():
# Unmatched opening bracket
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("func(arg1, arg2")
# Unmatched closing bracket
codeflash_output = ac._split_top_level_args("arg1, arg2)")
def test_mixed_brackets():
# Different types of brackets
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("func([arg1, arg2], {key: value}), arg3")
codeflash_output = ac._split_top_level_args("[func(arg1, arg2), {key: value}], arg3")
def test_large_scale():
# Long argument list
ac = AssertCleanup()
large_input = ",".join(f"arg{i}" for i in range(1000))
large_output = [f"arg{i}" for i in range(1000)]
codeflash_output = ac._split_top_level_args(large_input)
# Deeply nested structures
deep_nested_input = "func" + "".join(f"({i}" for i in range(100)) + "".join(")" for i in range(100))
codeflash_output = ac._split_top_level_args(deep_nested_input)
def test_special_characters():
# Arguments with special characters
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("arg1, arg2_with_special_chars!@#$%^&*(), arg3")
def test_edge_cases_with_commas():
# Commas within strings
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("arg1, 'arg2, still arg2', arg3")
# Run the tests
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 __future__ import annotations
# imports
import pytest # used for our unit tests
from codeflash.code_utils.code_replacer import AssertCleanup
# unit tests
# Basic Functionality
def test_single_argument():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("arg1")
def test_multiple_top_level_arguments():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("arg1,arg2,arg3")
# Whitespace Handling
def test_leading_trailing_whitespace():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args(" arg1 , arg2 ")
def test_whitespace_between_arguments():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("arg1 , arg2 , arg3")
# Nested Delimiters
def test_single_level_nesting():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("func(arg1,arg2),arg3")
def test_multiple_levels_nesting():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("func1(func2(arg1,arg2)),arg3")
# Mixed Delimiters
def test_mixed_delimiters():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("func1([arg1,arg2]),{key: value}")
def test_complex_nesting():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("func1([arg1,{key: value}]),arg2")
# Edge Cases
def test_empty_string():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("")
def test_single_comma():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args(",")
def test_commas_only():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args(",,,")
def test_unmatched_delimiters():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("func(arg1,arg2")
codeflash_output = ac._split_top_level_args("[arg1,arg2")
codeflash_output = ac._split_top_level_args("{key: value")
# Special Characters
def test_special_characters():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("arg1,arg!@#2,arg3$%^")
def test_quoted_strings():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("\"arg1,arg2\",arg3")
# Large Scale Test Cases
def test_large_number_of_arguments():
ac = AssertCleanup()
large_input = ",".join(f"arg{i}" for i in range(1, 1001))
expected_output = [f"arg{i}" for i in range(1, 1001)]
codeflash_output = ac._split_top_level_args(large_input)
def test_large_arguments():
ac = AssertCleanup()
large_arg1 = "a" * 1000
large_arg2 = "b" * 1000
large_input = f"{large_arg1},{large_arg2}"
codeflash_output = ac._split_top_level_args(large_input)
# Performance and Scalability
def test_long_nested_structures():
ac = AssertCleanup()
nested_input = "func" + "(".join(["func" for _ in range(100)]) + "(arg)" + ")" * 100
codeflash_output = ac._split_top_level_args(nested_input)
def test_large_input_string():
ac = AssertCleanup()
large_input = "func1([" + ",".join(f"arg{i}" for i in range(500)) + "])," + "func2({" + ",".join(f"key{i}: value{i}" for i in range(500)) + "})"
expected_output = ["func1([" + ",".join(f"arg{i}" for i in range(500)) + "])", "func2({" + ",".join(f"key{i}: value{i}" for i in range(500)) + "})"]
codeflash_output = ac._split_top_level_args(large_input)
# 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__split_top_level_args():
AssertCleanup._split_top_level_args(AssertCleanup(), '),(,\t')…(`clean_concolic_tests`) 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.
⚡️ Codeflash found optimizations for this PR📄 46% (0.46x) speedup for
|
|
context for #26 (comment) : the file got moved which is why codeflash optimizes again |
codeflash-ai bot
added a commit
that referenced
this pull request
Feb 27, 2025
…26 (`clean_concolic_tests`) - **Explanation**: - We optimize the character check by using a dictionary, `delimiters`, that maps each character to its corresponding depth adjustment value. This avoids multiple `if-elif` statements and performs a single dictionary lookup. - The loop iterates through each character once, providing an efficient way to split the args string. The overall logic and output remain unchanged.
⚡️ Codeflash found optimizations for this PR📄 31% (0.31x) speedup for
|
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 82 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | ✅ 2 Passed |
| 📊 Tests Coverage | undefined |
🌀 Generated Regression Tests Details
from __future__ import annotations
# imports
import pytest # used for our unit tests
from codeflash.code_utils.concolic_utils import AssertCleanup
# unit tests
# Test basic functionality
def test_basic_functionality():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("a,b,c")
codeflash_output = ac._split_top_level_args("arg1,arg2,arg3")
# Test nested structures
def test_single_level_nesting():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("a,(b,c),d")
codeflash_output = ac._split_top_level_args("x,[y,z],w")
codeflash_output = ac._split_top_level_args("1,{2,3},4")
def test_multiple_level_nesting():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("a,(b,(c,d)),e")
codeflash_output = ac._split_top_level_args("x,[y,{z}],w")
# Test edge cases
def test_empty_string():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("")
def test_single_argument():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("a")
codeflash_output = ac._split_top_level_args("(a,b)")
def test_trailing_comma():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("a,b,")
codeflash_output = ac._split_top_level_args("a,")
def test_leading_comma():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args(",a,b")
codeflash_output = ac._split_top_level_args(",a")
def test_multiple_commas():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("a,,b")
codeflash_output = ac._split_top_level_args(",,,")
# Test whitespace handling
def test_whitespace_around_arguments():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args(" a , b , c ")
codeflash_output = ac._split_top_level_args(" arg1 ,arg2 , arg3 ")
def test_whitespace_inside_nested_structures():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("a, ( b, c ), d")
codeflash_output = ac._split_top_level_args("x, [ y , z ], w")
# Test special characters
def test_special_characters_in_arguments():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("a,b,c!@#")
codeflash_output = ac._split_top_level_args("arg1,arg2,arg3$%^")
def test_special_characters_inside_nested_structures():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("a,(b,c!@#),d")
codeflash_output = ac._split_top_level_args("x,[y,z$%^],w")
# Test large scale test cases
def test_large_scale():
ac = AssertCleanup()
large_input = ",".join([f"arg{i}" for i in range(1000)])
expected_output = [f"arg{i}" for i in range(1000)]
codeflash_output = ac._split_top_level_args(large_input)
nested_input = ",".join([f"(arg{i},{i})" for i in range(1000)])
expected_nested_output = [f"(arg{i},{i})" for i in range(1000)]
codeflash_output = ac._split_top_level_args(nested_input)
# Test invalid inputs
def test_unbalanced_nested_structures():
ac = AssertCleanup()
with pytest.raises(Exception):
ac._split_top_level_args("a,(b,c,d")
with pytest.raises(Exception):
ac._split_top_level_args("x,[y,z],w]")
def test_mismatched_nested_structures():
ac = AssertCleanup()
with pytest.raises(Exception):
ac._split_top_level_args("a,(b,[c,d]),e")
with pytest.raises(Exception):
ac._split_top_level_args("x,{y,(z]},w")
# 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
# imports
import pytest # used for our unit tests
from codeflash.code_utils.concolic_utils import AssertCleanup
# unit tests
# Basic Functionality
def test_single_argument():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("arg1")
codeflash_output = ac._split_top_level_args(" arg1 ")
def test_multiple_arguments():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("arg1,arg2,arg3")
codeflash_output = ac._split_top_level_args("arg1, arg2, arg3")
# Nested Structures
def test_nested_parentheses():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("func1(arg1, arg2), func2(arg3, arg4)")
codeflash_output = ac._split_top_level_args("func(arg1, (arg2, arg3))")
def test_nested_brackets():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("list1[arg1, arg2], list2[arg3, arg4]")
codeflash_output = ac._split_top_level_args("list[arg1, [arg2, arg3]]")
def test_nested_braces():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("dict1{key1: val1, key2: val2}, dict2{key3: val3, key4: val4}")
codeflash_output = ac._split_top_level_args("dict{key1: val1, key2: {key3: val3, key4: val4}}")
# Mixed Nested Structures
def test_mixed_nested_structures():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("mix1(arg1, [arg2, arg3]), mix2{key: val}")
codeflash_output = ac._split_top_level_args("mix(arg1, [arg2, {key: val}])")
# Edge Cases
def test_empty_string():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("")
def test_single_comma():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args(",")
def test_leading_and_trailing_commas():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args(",arg1,arg2,")
def test_unbalanced_structures():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("func(arg1, arg2")
codeflash_output = ac._split_top_level_args("list[arg1, arg2")
codeflash_output = ac._split_top_level_args("dict{key1: val1, key2: val2")
# Whitespace Handling
def test_whitespace_between_arguments():
ac = AssertCleanup()
codeflash_output = ac._split_top_level_args("arg1 , arg2 , arg3 ")
codeflash_output = ac._split_top_level_args(" arg1, arg2 ,arg3")
# Large Scale Test Cases
def test_large_number_of_arguments():
ac = AssertCleanup()
large_input = ",".join([f"arg{i}" for i in range(1, 1001)])
expected_output = [f"arg{i}" for i in range(1, 1001)]
codeflash_output = ac._split_top_level_args(large_input)
def test_large_number_of_nested_arguments():
ac = AssertCleanup()
large_input = ",".join([f"func{i}(arg{i*2-1}, arg{i*2})" for i in range(1, 501)])
expected_output = [f"func{i}(arg{i*2-1}, arg{i*2})" for i in range(1, 501)]
codeflash_output = ac._split_top_level_args(large_input)
# Performance and Scalability
def test_very_long_single_argument():
ac = AssertCleanup()
large_argument = "func(" + "a" * 10000 + ")"
codeflash_output = ac._split_top_level_args(large_argument)
def test_deeply_nested_structure():
ac = AssertCleanup()
deeply_nested = "(" * 1000 + "arg" + ")" * 1000
codeflash_output = ac._split_top_level_args(deeply_nested)
# Running the tests
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__split_top_level_args():
AssertCleanup._split_top_level_args(AssertCleanup(), '),(,\t')To test or edit this optimization locally git merge codeflash/optimize-pr26-2025-02-27T02.45.52
codeflash-ai bot
added a commit
that referenced
this pull request
Feb 27, 2025
…#26 (`clean_concolic_tests`) Here's the optimized version of the Python program. The main focus was on optimizing the regular expressions and the `if` conditions. Some parts of string processing were also simplified.
Comment on lines
+49
to
+53
|
|
||
| for char in args_str: | ||
| if char in "([{": | ||
| depth += 1 | ||
| current.append(char) |
There was a problem hiding this comment.
Suggested change
| for char in args_str: | |
| if char in "([{": | |
| depth += 1 | |
| current.append(char) | |
| continue | |
| current.append(char) | |
| def __init__(self): | |
| self.assert_pattern = re.compile(r"\s*assert\s+(.*?)(?:\s*==\s*.*)?$") | |
| self.unittest_pattern = re.compile(r"(\s*)self\.assert([A-Za-z]+)\((.*)\)$") | |
⚡️ Codeflash found optimizations for this PR📄 39% (0.39x) speedup for
|
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 123 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.concolic_utils import AssertCleanup
# unit tests
def test_simple_assert_statements():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("assert x == 1")
codeflash_output = ac._transform_assert_line("assert y")
codeflash_output = ac._transform_assert_line("assert not z")
def test_complex_assert_statements():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("assert (x + y) == z")
codeflash_output = ac._transform_assert_line("assert x > 0 and y < 10")
codeflash_output = ac._transform_assert_line("assert func(x, y) == expected")
def test_assert_with_trailing_commas_semicolons():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("assert x == 1,")
codeflash_output = ac._transform_assert_line("assert y;")
codeflash_output = ac._transform_assert_line("assert not z,;")
def test_assert_with_indentation():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line(" assert x == 1")
codeflash_output = ac._transform_assert_line(" assert y")
codeflash_output = ac._transform_assert_line(" assert not z")
def test_unittest_simple_arguments():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("self.assertEqual(x, 1)")
codeflash_output = ac._transform_assert_line("self.assertTrue(y)")
codeflash_output = ac._transform_assert_line("self.assertFalse(z)")
def test_unittest_complex_arguments():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("self.assertEqual((x + y), z)")
codeflash_output = ac._transform_assert_line("self.assertTrue(x > 0 and y < 10)")
codeflash_output = ac._transform_assert_line("self.assertEqual(func(x, y), expected)")
def test_unittest_nested_arguments():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("self.assertEqual([1, 2, (3, 4)], [1, 2, (3, 4)])")
codeflash_output = ac._transform_assert_line("self.assertTrue((x, y) in [(1, 2), (3, 4)])")
codeflash_output = ac._transform_assert_line('self.assertEqual({"a": 1, "b": {"c": 2}}, {"a": 1, "b": {"c": 2}})')
def test_unittest_with_trailing_commas_semicolons():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("self.assertEqual(x, 1),")
codeflash_output = ac._transform_assert_line("self.assertTrue(y);")
codeflash_output = ac._transform_assert_line("self.assertFalse(z,);")
def test_unittest_with_indentation():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line(" self.assertEqual(x, 1)")
codeflash_output = ac._transform_assert_line(" self.assertTrue(y)")
codeflash_output = ac._transform_assert_line(" self.assertFalse(z)")
def test_lines_not_transformed():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("print(x)")
codeflash_output = ac._transform_assert_line("if x == 1:")
codeflash_output = ac._transform_assert_line("return x")
def test_empty_or_whitespace_only_lines():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("")
codeflash_output = ac._transform_assert_line(" ")
def test_edge_cases():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("assert not")
codeflash_output = ac._transform_assert_line("self.assertEqual()")
codeflash_output = ac._transform_assert_line("assert")
def test_non_standard_assert_statements():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("assert (x == 1)")
codeflash_output = ac._transform_assert_line("assert (y,)")
codeflash_output = ac._transform_assert_line("assert (not z,)")
def test_mixed_content_in_single_line():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("assert x == 1; print(x)")
codeflash_output = ac._transform_assert_line("assert y,; print(y)")
codeflash_output = ac._transform_assert_line("assert not z;")
def test_comments_in_assert_lines():
ac = AssertCleanup()
codeflash_output = ac._transform_assert_line("assert x == 1 # Check if x is 1")
codeflash_output = ac._transform_assert_line("assert y # Ensure y is True")
codeflash_output = ac._transform_assert_line("assert not z # z should be False")
# 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
@pytest.fixture
def assert_cleanup():
return AssertCleanup()
# Basic `assert` Statements
def test_simple_assert_statement(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert x == 1")
codeflash_output = assert_cleanup._transform_assert_line("assert y")
def test_assert_with_trailing_comma(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert x == 1,")
codeflash_output = assert_cleanup._transform_assert_line("assert y,")
def test_assert_with_trailing_semicolon(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert x == 1;")
codeflash_output = assert_cleanup._transform_assert_line("assert y;")
# `assert` Statements with `not`
def test_assert_with_not(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert not x")
codeflash_output = assert_cleanup._transform_assert_line("assert not (x == 1)")
def test_assert_with_not_and_trailing_chars(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert not x,")
codeflash_output = assert_cleanup._transform_assert_line("assert not (x == 1);")
# `unittest` Assert Statements
def test_basic_unittest_assert(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual(x, 1)")
codeflash_output = assert_cleanup._transform_assert_line("self.assertTrue(y)")
def test_unittest_assert_with_multiple_args(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual(x, 1, 'message')")
codeflash_output = assert_cleanup._transform_assert_line("self.assertIn(a, b, 'another message')")
def test_unittest_assert_with_nested_args(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual((x, y), (1, 2))")
codeflash_output = assert_cleanup._transform_assert_line("self.assertDictEqual({'a': 1}, {'a': 1})")
# Indentation Variations
def test_assert_with_indentation(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line(" assert x == 1")
codeflash_output = assert_cleanup._transform_assert_line(" assert y")
codeflash_output = assert_cleanup._transform_assert_line(" self.assertEqual(x, 1)")
codeflash_output = assert_cleanup._transform_assert_line(" self.assertTrue(y)")
# Edge Cases
def test_empty_lines(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("")
codeflash_output = assert_cleanup._transform_assert_line(" ")
def test_lines_without_assert(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("print('Hello, world!')")
codeflash_output = assert_cleanup._transform_assert_line("x = 1")
def test_invalid_assert_statements(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert")
codeflash_output = assert_cleanup._transform_assert_line("assert == 1")
def test_invalid_unittest_assert_statements(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual()")
codeflash_output = assert_cleanup._transform_assert_line("self.assertTrue()")
# Large Scale Test Cases
def test_large_number_of_args_in_unittest_assert(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual(x, 1, 'message', 'another message', 'yet another message')")
def test_complex_expressions_in_assert(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert (x == 1 and y == 2) or (a == b)")
codeflash_output = assert_cleanup._transform_assert_line("assert not (x == 1 or y == 2)")
# Special Characters and Strings
def test_assert_with_special_characters(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line('assert x == "a, b, c"')
codeflash_output = assert_cleanup._transform_assert_line('assert y == "1;2;3"')
def test_unittest_assert_with_special_characters(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line('self.assertEqual(x, "a, b, c")')
codeflash_output = assert_cleanup._transform_assert_line('self.assertEqual(y, "1;2;3")')
# Comments and Inline Comments
def test_assert_with_comments(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("assert x == 1 # Check if x is 1")
codeflash_output = assert_cleanup._transform_assert_line("assert y # Check if y is True")
def test_unittest_assert_with_comments(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("self.assertEqual(x, 1) # Check if x equals 1")
codeflash_output = assert_cleanup._transform_assert_line("self.assertTrue(y) # Check if y is True")
# Mixed Case Sensitivity
def test_mixed_case_assert(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("AsSeRt x == 1")
codeflash_output = assert_cleanup._transform_assert_line("aSsErT y")
def test_mixed_case_unittest_assert(assert_cleanup):
codeflash_output = assert_cleanup._transform_assert_line("self.AsSeRtEqual(x, 1)")
codeflash_output = assert_cleanup._transform_assert_line("self.aSsErTTrue(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.concolic_utils import AssertCleanup
def test_AssertCleanup__transform_assert_line():
AssertCleanup._transform_assert_line(AssertCleanup(), '\x1cself.assertA(\x00)')
def test_AssertCleanup__transform_assert_line_2():
AssertCleanup._transform_assert_line(AssertCleanup(), 'assert\t')
def test_AssertCleanup__transform_assert_line_3():
AssertCleanup._transform_assert_line(AssertCleanup(), '')To test or edit this optimization locally git merge codeflash/optimize-pr26-2025-02-27T04.16.34
codeflash-ai bot
added a commit
that referenced
this pull request
Feb 27, 2025
…concolic_tests`) To optimize the program for better performance, consider the following approaches. 1. **Batch Processing**: Instead of transforming the asserts line-by-line within the loop, we can accumulate assert lines and process them in bulk. 2. **Efficient String Operations**: Minimize the number of string operations and regular expression matching by using direct AST manipulation. 3. **Optimizing AST Walk**: Handle the bulk processing of relevant AST nodes within the single pass over the tree. Here's the optimized version. ### Changes Made. 1. **Efficient String Handling**: Optimized `_transform_assert_line()` by reducing redundant operations. 2. **Batch Processing**: The `transform_asserts()` function processes lines in one pass and transformed lines in bulk at the end. 3. **AST Optimization**: A single subclass of `ast.NodeTransformer` (`AssertTransform`) handles both `Assert` and `FunctionDef` node transformations in one traversal. These changes improve readability and maintainability while also boosting the performance by reducing the complexity of operations performed per line and reusing parsing results effectively.
Comment on lines
+11
to
+14
| result_lines = [] | ||
|
|
||
| for line in lines: | ||
| transformed = self._transform_assert_line(line) |
There was a problem hiding this comment.
Suggested change
| result_lines = [] | |
| for line in lines: | |
| transformed = self._transform_assert_line(line) | |
| transformed_lines = [] | |
| transformed_lines.append(transformed) | |
| transformed_lines.append(line) | |
| return "\n".join(transformed_lines) |
⚡️ Codeflash found optimizations for this PR📄 19% (0.19x) speedup for
|
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | ✅ 39 Passed |
| 🌀 Generated Regression Tests | ✅ 37 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | undefined |
⚙️ Existing Unit Tests Details
- codeflash_concolic_3vfglg2h/tmpg1i95eb8/test_concolic_coverage.py
- test_code_utils.py🌀 Generated Regression Tests Details
from __future__ import annotations
import ast
import re
from typing import Optional
# imports
import pytest # used for our unit tests
from codeflash.code_utils.concolic_utils import clean_concolic_tests
# unit tests
def test_basic_assert():
code = "def test_func():\n assert x == 1"
expected = "def test_func():\n x"
codeflash_output = clean_concolic_tests(code)
def test_basic_unittest():
code = "def test_func():\n self.assertTrue(x)"
expected = "def test_func():\n x"
codeflash_output = clean_concolic_tests(code)
def test_empty_input():
code = ""
expected = ""
codeflash_output = clean_concolic_tests(code)
def test_no_asserts():
code = "def test_no_asserts():\n pass"
expected = "def test_no_asserts():\n pass"
codeflash_output = clean_concolic_tests(code)
def test_only_comments():
code = "# This is a comment"
expected = "# This is a comment"
codeflash_output = clean_concolic_tests(code)
def test_nested_assert():
code = "def test_func():\n assert (x == 1 and y == 2)"
expected = "def test_func():\n assert (x == 1 and y == 2)"
codeflash_output = clean_concolic_tests(code)
def test_function_call_assert():
code = "def test_func():\n assert func(x) == 1"
expected = "def test_func():\n func(x)"
codeflash_output = clean_concolic_tests(code)
def test_invalid_code():
code = "def test_invalid_code(: pass"
expected = "def test_invalid_code(: pass"
codeflash_output = clean_concolic_tests(code)
def test_mixed_content():
code = "def test_mixed():\n x = 1\n assert x == 1\n y = 2\n assert y == 2"
expected = "def test_mixed():\n x = 1\n x\n y = 2\n y"
codeflash_output = clean_concolic_tests(code)
def test_multiple_functions():
code = "def test_func1():\n assert x == 1\n\ndef test_func2():\n assert y == 2"
expected = "def test_func1():\n x\n\ndef test_func2():\n y"
codeflash_output = clean_concolic_tests(code)
def test_multiple_args():
code = "def test_func():\n self.assertEqual(x, y, 'message')"
expected = "def test_func():\n x"
codeflash_output = clean_concolic_tests(code)
def test_indentation():
code = "def test_func():\n if x:\n assert x == 1"
expected = "def test_func():\n if x:\n x"
codeflash_output = clean_concolic_tests(code)
def test_large_scale():
code = "def test_many_asserts():\n" + "\n".join([f" assert x == {i}" for i in range(1000)])
expected = "def test_many_asserts():\n" + "\n".join([f" x" for i in range(1000)])
codeflash_output = clean_concolic_tests(code)
def test_comments():
code = "def test_func():\n assert x == 1 # Check if x equals 1"
expected = "def test_func():\n x # Check if x equals 1"
codeflash_output = clean_concolic_tests(code)
def test_trailing():
code = "def test_func():\n assert x == 1,\n assert x == 1;"
expected = "def test_func():\n x\n x"
codeflash_output = clean_concolic_tests(code)
def test_decorated():
code = "@decorator\ndef test_func():\n assert x == 1"
expected = "@decorator\ndef test_func():\n x"
codeflash_output = clean_concolic_tests(code)
def test_lambda():
code = "def test_func():\n assert (lambda x: x + 1)(x) == 2"
expected = "def test_func():\n (lambda x: x + 1)(x)"
codeflash_output = clean_concolic_tests(code)
def test_walrus():
code = "def test_func():\n assert (x := func()) == 1"
expected = "def test_func():\n (x := func())"
codeflash_output = clean_concolic_tests(code)
def test_positional_only():
code = "def test_func(x, /):\n assert x == 1"
expected = "def test_func(x, /):\n x"
codeflash_output = clean_concolic_tests(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 ast
import re
from typing import Optional
# imports
import pytest # used for our unit tests
from codeflash.code_utils.concolic_utils import clean_concolic_tests
# unit tests
# Basic Assertions
def test_simple_assert_statements():
code = "def test_example():\n assert x == y"
expected = "def test_example():\n assert x == y"
codeflash_output = clean_concolic_tests(code)
def test_negated_assert_statements():
code = "def test_example():\n assert not x"
expected = "def test_example():\n not x"
codeflash_output = clean_concolic_tests(code)
# Complex Assertions
def test_multiple_conditions():
code = "def test_example():\n assert x == y and y == z"
expected = "def test_example():\n assert x == y and y == z"
codeflash_output = clean_concolic_tests(code)
def test_assert_with_function_call():
code = "def test_example():\n assert func(x) == y"
expected = "def test_example():\n func(x)"
codeflash_output = clean_concolic_tests(code)
# Unit Test Assertions
def test_simple_unittest_assertions():
code = "def test_example():\n self.assertEqual(x, y)"
expected = "def test_example():\n x"
codeflash_output = clean_concolic_tests(code)
def test_complex_unittest_assertions():
code = "def test_example():\n self.assertTrue(x > 0 and y < 0)"
expected = "def test_example():\n x > 0 and y < 0"
codeflash_output = clean_concolic_tests(code)
# Syntax Errors
def test_malformed_code():
code = "def test_example():\n assert x =="
expected = "def test_example():\n assert x =="
codeflash_output = clean_concolic_tests(code)
def test_unclosed_brackets():
code = "def test_example():\n assert (x == y"
expected = "def test_example():\n assert (x == y"
codeflash_output = clean_concolic_tests(code)
# Indentation Variations
def test_correctly_indented_code():
code = "def test_example():\n assert x == y"
expected = "def test_example():\n assert x == y"
codeflash_output = clean_concolic_tests(code)
def test_incorrectly_indented_code():
code = "def test_example():\nassert x == y"
expected = "def test_example():\nassert x == y"
codeflash_output = clean_concolic_tests(code)
# Function Definitions
def test_function_with_assertions():
code = "def test_example():\n assert x == y"
expected = "def test_example():\n assert x == y"
codeflash_output = clean_concolic_tests(code)
def test_function_without_assertions():
code = "def test_example():\n x = y + 1"
expected = "def test_example():\n x = y + 1"
codeflash_output = clean_concolic_tests(code)
# Nested Functions
def test_nested_functions():
code = "def test_example():\n def helper():\n assert x == y\n helper()"
expected = "def test_example():\n def helper():\n assert x == y\n helper()"
codeflash_output = clean_concolic_tests(code)
# Large Scale Test Cases
def test_large_number_of_assertions():
code = "def test_example():\n" + "\n".join(f" assert i == {i}" for i in range(1000))
expected = "def test_example():\n" + "\n".join(f" assert i == {i}" for i in range(1000))
codeflash_output = clean_concolic_tests(code)
def test_complex_function_with_many_assertions():
code = "def test_example():\n" + "\n".join(f" if i % 2 == 0:\n assert i % 2 == 0\n else:\n assert i % 2 != 0" for i in range(100))
expected = "def test_example():\n" + "\n".join(f" if i % 2 == 0:\n assert i % 2 == 0\n else:\n assert i % 2 != 0" for i in range(100))
codeflash_output = clean_concolic_tests(code)
# Edge Cases
def test_empty_function_definitions():
code = "def test_example():\n pass"
expected = "def test_example():\n pass"
codeflash_output = clean_concolic_tests(code)
def test_functions_with_comments():
code = "def test_example():\n # This is a comment\n assert x == y"
expected = "def test_example():\n # This is a comment\n assert x == y"
codeflash_output = clean_concolic_tests(code)
# Mixed Content
def test_functions_with_mixed_content():
code = "def test_example():\n x = 1\n assert x == 1\n y = 2\n assert y == 2"
expected = "def test_example():\n x = 1\n assert x == 1\n y = 2\n assert y == 2"
codeflash_output = clean_concolic_tests(code)
# 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 clean_concolic_tests
import pytest
def test_clean_concolic_tests():
with pytest.raises(TypeError, match='compile\\(\\)\\ arg\\ 1\\ must\\ be\\ a\\ string,\\ bytes\\ or\\ AST\\ object'):
clean_concolic_tests('')To test or edit this optimization locally git merge codeflash/optimize-pr26-2025-02-27T19.08.07
misrasaurabh1
approved these changes
Feb 28, 2025
…-02-27T02.40.10 ⚡️ Speed up method `AssertCleanup.transform_asserts` by 46% in PR #26 (`clean_concolic_tests`)
|
This PR is now faster! 🚀 @KRRT7 accepted my optimizations from: |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
addresses CF-526