
import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_add_unique_arguments(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.add(10, 7)
        _dynamic_test(
            self,
            result == 17,
            "add(10, 7) returns correct result",
            f"Expected 17, got {result}",
        )

    def test_add_cached_result(self):
        import user_code
        importlib.reload(user_code)
        # Call once to populate cache
        user_code.add(4, 6)
        # Call again to check cached result
        result = user_code.add(4, 6)
        _dynamic_test(
            self,
            result == 10,
            "add(4, 6) returns cached result",
            f"Expected 10, got {result}",
        )

    def test_multiply_unique_arguments(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.multiply(3, 7)
        _dynamic_test(
            self,
            result == 21,
            "multiply(3, 7) returns correct result",
            f"Expected 21, got {result}",
        )

    def test_multiply_cached_result(self):
        import user_code
        importlib.reload(user_code)
        user_code.multiply(5, 6)
        result = user_code.multiply(5, 6)
        _dynamic_test(
            self,
            result == 30,
            "multiply(5, 6) returns cached result",
            f"Expected 30, got {result}",
        )

    def test_kwargs_and_positional_args(self):
        import user_code
        importlib.reload(user_code)
        @user_code.memoize
        def func(a, b=2, c=3):
            return a + b + c
        result1 = func(1, c=4, b=5)
        result2 = func(1, b=5, c=4)
        _dynamic_test(
            self,
            result1 == 10 and result2 == 10,
            "Decorator works for positional and keyword arguments (order insensitive)",
            f"Expected 10 for both calls, got {result1} and {result2}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Master the art of Python decorators, from foundational concepts to advanced applications. This course guides you through the mechanics, use cases, and best practices of decorators, empowering you to write more expressive and reusable Python code.

Explore the foundational concepts of Python decorators, including their syntax, how they work, and why they're useful.

Delve deeper into decorators by exploring arguments, chaining, and built-in decorators.

Explore Python's built-in decorators and practical use cases for custom decorators.

Apply your knowledge of decorators in a series of hands-on coding challenges.

Challenge: Memoization Decorator

解答