⚡️ Speed up function parse_log_pytest by 301%

[codeflash-ai]

📄 301% (3.01x) speedup for parse_log_pytest in evaluation/benchmarks/testgeneval/log_parsers.py

⏱️ Runtime : 3.06 milliseconds → 762 microseconds (best of 950 runs)

📝 Explanation and details

Optimizations Made.

1. Set for Statuses: Precomputed a set of status values from TestStatus to use in membership checks, which is faster than using a list comprehension with startswith in a loop.
2. Partition Method: Used line.partition(' ')[0] to extract the status prefix from the line more efficiently by splitting only at the first space. This avoids unnecessary full split() calls unless absolutely needed.
3. Direct Status Assignment: Used the extracted status directly for status map assignment, saving repetitive extraction operations.

These changes will reduce the runtime complexity associated with frequently checking and parsing each line, particularly when logs are large.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

from unittest.mock import MagicMock

# imports
import pytest  # used for our unit tests
# function to test
from evaluation.benchmarks.testgeneval.constants import TestStatus
from evaluation.benchmarks.testgeneval.log_parsers import parse_log_pytest

# unit tests

# Mocking TestStatus for testing
TestStatus = MagicMock()
TestStatus.PASSED.value = "PASSED"
TestStatus.FAILED.value = "FAILED"
TestStatus.ERROR.value = "ERROR"

def test_single_passed_test_case():
    # Single test case with "PASSED" status
    log = "PASSED test_case_1"
    expected_output = {"test_case_1": "PASSED"}
    codeflash_output = parse_log_pytest(log)

def test_single_failed_test_case():
    # Single test case with "FAILED" status
    log = "FAILED test_case_2"
    expected_output = {"test_case_2": "FAILED"}
    codeflash_output = parse_log_pytest(log)

def test_multiple_mixed_statuses():
    # Multiple test cases with mixed statuses
    log = "PASSED test_case_1\nFAILED test_case_2\nPASSED test_case_3"
    expected_output = {
        "test_case_1": "PASSED",
        "test_case_2": "FAILED",
        "test_case_3": "PASSED"
    }
    codeflash_output = parse_log_pytest(log)

def test_empty_log():
    # Empty log input
    log = ""
    expected_output = {}
    codeflash_output = parse_log_pytest(log)

def test_no_recognizable_status():
    # Log with no recognizable status
    log = "UNKNOWN test_case_1\nUNKNOWN test_case_2"
    expected_output = {}
    codeflash_output = parse_log_pytest(log)

def test_malformed_lines():
    # Log with malformed lines
    log = "PASSED\nFAILED\nPASSED test_case_1"
    expected_output = {"test_case_1": "PASSED"}
    codeflash_output = parse_log_pytest(log)

def test_failed_status_with_special_formatting():
    # Log with "FAILED" status having special formatting
    log = "FAILED - test_case_1"
    expected_output = {"test_case_1": "FAILED"}
    codeflash_output = parse_log_pytest(log)

def test_unusual_characters_in_test_case_names():
    # Test case names with unusual characters
    log = "PASSED test_case_1\nFAILED test_case_@!#"
    expected_output = {
        "test_case_1": "PASSED",
        "test_case_@!#": "FAILED"
    }
    codeflash_output = parse_log_pytest(log)

def test_large_log_with_many_entries():
    # Large log with many entries
    log = "\n".join(f"PASSED test_case_{i}" for i in range(1000))
    expected_output = {f"test_case_{i}": "PASSED" for i in range(1000)}
    codeflash_output = parse_log_pytest(log)

def test_interleaved_non_test_lines():
    # Logs interspersed with non-test related lines
    log = "SETUP\nPASSED test_case_1\nTEARDOWN\nFAILED test_case_2"
    expected_output = {
        "test_case_1": "PASSED",
        "test_case_2": "FAILED"
    }
    codeflash_output = parse_log_pytest(log)

def test_multiple_status_updates_for_same_test_case():
    # Logs where the same test case appears multiple times with different statuses
    log = "PASSED test_case_1\nFAILED test_case_1\nPASSED test_case_2"
    expected_output = {
        "test_case_1": "FAILED",  # Last occurrence should determine the status
        "test_case_2": "PASSED"
    }
    codeflash_output = parse_log_pytest(log)

def test_invalid_input_types():
    # Non-string inputs should raise an error
    with pytest.raises(AttributeError):
        parse_log_pytest(None)
    with pytest.raises(AttributeError):
        parse_log_pytest(123)

def test_unexpected_enum_values():
    # Simulating unexpected status values
    TestStatus.UNKNOWN.value = "UNKNOWN"
    log = "UNKNOWN test_case_1\nPASSED test_case_2"
    expected_output = {
        "test_case_2": "PASSED"
    }
    codeflash_output = parse_log_pytest(log)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from enum import Enum  # used to define TestStatus for testing purposes

# imports
import pytest  # used for our unit tests
from evaluation.benchmarks.testgeneval.log_parsers import parse_log_pytest


# Mocking TestStatus for testing purposes
class TestStatus(Enum):
    PASSED = "PASSED"
    FAILED = "FAILED"
    SKIPPED = "SKIPPED"
from evaluation.benchmarks.testgeneval.log_parsers import parse_log_pytest

# unit tests

def test_single_passed_test():
    # Test with a single passed test case
    log = "PASSED test_case_1"
    expected = {"test_case_1": "PASSED"}
    codeflash_output = parse_log_pytest(log)

def test_single_failed_test():
    # Test with a single failed test case
    log = "FAILED test_case_2"
    expected = {"test_case_2": "FAILED"}
    codeflash_output = parse_log_pytest(log)

def test_multiple_tests():
    # Test with multiple test cases having different statuses
    log = "PASSED test_case_1\nFAILED test_case_2\nSKIPPED test_case_3"
    expected = {
        "test_case_1": "PASSED",
        "test_case_2": "FAILED",
        "test_case_3": "SKIPPED"
    }
    codeflash_output = parse_log_pytest(log)

def test_empty_log():
    # Test with an empty log
    log = ""
    expected = {}
    codeflash_output = parse_log_pytest(log)

def test_malformed_lines():
    # Test with malformed lines that should be ignored
    log = "test_case_1\nPASSED\n  PASSED   test_case_1  "
    expected = {"test_case_1": "PASSED"}
    codeflash_output = parse_log_pytest(log)

def test_unknown_status():
    # Test with a line containing an unknown status
    log = "UNKNOWN test_case_1"
    expected = {}
    codeflash_output = parse_log_pytest(log)

def test_special_characters():
    # Test with special characters in test names
    log = "PASSED test_case-1\nFAILED test_case_2"
    expected = {
        "test_case-1": "PASSED",
        "test_case_2": "FAILED"
    }
    codeflash_output = parse_log_pytest(log)

def test_non_ascii_characters():
    # Test with non-ASCII characters in test names
    log = "PASSED test_case_ñ"
    expected = {"test_case_ñ": "PASSED"}
    codeflash_output = parse_log_pytest(log)

def test_large_log():
    # Test with a large log containing many entries
    log = "\n".join(f"PASSED test_case_{i}" for i in range(1000))
    expected = {f"test_case_{i}": "PASSED" for i in range(1000)}
    codeflash_output = parse_log_pytest(log)

def test_failed_test_parsing():
    # Test with a failed test case that requires additional parsing
    log = "FAILED - test_case_1"
    expected = {"test_case_1": "FAILED"}
    codeflash_output = parse_log_pytest(log)

def test_different_line_endings():
    # Test with different line endings
    log = "PASSED test_case_1\r\nFAILED test_case_2\nSKIPPED test_case_3"
    expected = {
        "test_case_1": "PASSED",
        "test_case_2": "FAILED",
        "test_case_3": "SKIPPED"
    }
    codeflash_output = parse_log_pytest(log)

def test_non_string_input():
    # Test with non-string input to ensure type safety
    with pytest.raises(AttributeError):
        parse_log_pytest(None)
    with pytest.raises(AttributeError):
        parse_log_pytest(123)
    with pytest.raises(AttributeError):
        parse_log_pytest([])

def test_minimum_valid_input():
    # Test with the smallest possible valid log
    log = "PASSED a"
    expected = {"a": "PASSED"}
    codeflash_output = parse_log_pytest(log)

def test_maximum_valid_input():
    # Test with a log entry having a long test name
    long_test_name = "a" * 1000
    log = f"PASSED {long_test_name}"
    expected = {long_test_name: "PASSED"}
    codeflash_output = parse_log_pytest(log)

def test_all_possible_statuses():
    # Test with all possible statuses defined in TestStatus
    log = "\n".join(f"{status.value} test_case_{i}" for i, status in enumerate(TestStatus))
    expected = {f"test_case_{i}": status.value for i, status in enumerate(TestStatus)}
    codeflash_output = parse_log_pytest(log)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from evaluation.benchmarks.testgeneval.log_parsers import parse_log_pytest

def test_parse_log_pytest():
    parse_log_pytest('FAILED - \x00\x00\n')

def test_parse_log_pytest_2():
    parse_log_pytest('XFAIL')

To edit these changes git checkout codeflash/optimize-parse_log_pytest-m8wysg4g and push.