
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_valid(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.add(5, 7)
        _dynamic_test(
            self,
            result == 12,
            "add returns correct result for positive integers",
            f"Expected 12, got {result}",
        )

    def test_multiply_valid(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.multiply(2, 3, 4)
        _dynamic_test(
            self,
            result == 24,
            "multiply returns correct result for positive integers",
            f"Expected 24, got {result}",
        )

    def test_add_negative_argument(self):
        import user_code
        importlib.reload(user_code)
        with self.assertRaises(ValueError) as context:
            user_code.add(-1, 2)
        _dynamic_test(
            self,
            "positive integer" in str(context.exception).lower(),
            "ValueError raised for negative argument in add",
            f"Expected ValueError for negative argument in add, got {context.exception}",
        )

    def test_add_zero_argument(self):
        import user_code
        importlib.reload(user_code)
        with self.assertRaises(ValueError) as context:
            user_code.add(0, 2)
        _dynamic_test(
            self,
            "positive integer" in str(context.exception).lower(),
            "ValueError raised for zero argument in add",
            f"Expected ValueError for zero argument in add, got {context.exception}",
        )

    def test_add_non_integer_argument(self):
        import user_code
        importlib.reload(user_code)
        with self.assertRaises(ValueError) as context:
            user_code.add(1.5, 2)
        _dynamic_test(
            self,
            "positive integer" in str(context.exception).lower(),
            "ValueError raised for non-integer argument in add",
            f"Expected ValueError for non-integer argument in add, got {context.exception}",
        )

    def test_multiply_keyword_argument_invalid(self):
        import user_code
        importlib.reload(user_code)
        with self.assertRaises(ValueError) as context:
            user_code.multiply(a=1, b=2, c=-3)
        _dynamic_test(
            self,
            "positive integer" in str(context.exception).lower(),
            "ValueError raised for invalid keyword argument in multiply",
            f"Expected ValueError for invalid keyword argument in multiply, got {context.exception}",
        )

    def test_multiply_keyword_argument_valid(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.multiply(a=2, b=3, c=4)
        _dynamic_test(
            self,
            result == 24,
            "multiply returns correct result for valid keyword arguments",
            f"Expected 24, got {result}",
        )

    def test_decorator_with_many_args(self):
        code = """
def positive_integer_args(func):
    def wrapper(*args, **kwargs):
        for arg in args:
            if not isinstance(arg, int) or arg <= 0:
                raise ValueError('All arguments must be positive integers.')
        for value in kwargs.values():
            if not isinstance(value, int) or value <= 0:
                raise ValueError('All arguments must be positive integers.')
        return func(*args, **kwargs)
    return wrapper

@positive_integer_args
def sum_all(*args, **kwargs):
    return sum(args) + sum(kwargs.values())
"""
        ns = {}
        exec(code, ns)
        # Valid arguments
        result = ns['sum_all'](1, 2, 3, x=4, y=5)
        _dynamic_test(
            self,
            result == 15,
            "Decorator works with many positional and keyword arguments",
            f"Expected 15, got {result}",
        )
        # Negative positional argument
        with self.assertRaises(ValueError) as context:
            ns['sum_all'](1, 2, -3, x=4, y=5)
        _dynamic_test(
            self,
            "positive integer" in str(context.exception).lower(),
            "ValueError raised for negative positional argument in many args",
            f"Expected ValueError for negative positional argument, got {context.exception}",
        )
        # Zero keyword argument
        with self.assertRaises(ValueError) as context:
            ns['sum_all'](1, 2, 3, x=0, y=5)
        _dynamic_test(
            self,
            "positive integer" in str(context.exception).lower(),
            "ValueError raised for zero keyword argument in many args",
            f"Expected ValueError for zero keyword argument, got {context.exception}",
        )

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: Argument Validation Decorator

Oplossing