
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_rectangle_area(self):
        import user_code
        importlib.reload(user_code)
        Rectangle = getattr(user_code, 'Rectangle', None)
        _dynamic_test(
            self,
            Rectangle is not None and callable(Rectangle),
            "Rectangle class is defined",
            "Rectangle class is not defined or not callable",
        )
        rect = Rectangle(4, 5)
        area_method = getattr(rect, 'area', None)
        _dynamic_test(
            self,
            area_method is not None and callable(area_method),
            "area method is defined",
            "area method is not defined or not callable",
        )
        area = rect.area()
        _dynamic_test(
            self,
            area == 20,
            "area method returns correct value for (4, 5)",
            f"Expected area 20, got {area}",
        )

    def test_rectangle_perimeter(self):
        import user_code
        importlib.reload(user_code)
        Rectangle = getattr(user_code, 'Rectangle', None)
        rect = Rectangle(4, 5)
        perimeter_method = getattr(rect, 'perimeter', None)
        _dynamic_test(
            self,
            perimeter_method is not None and callable(perimeter_method),
            "perimeter method is defined",
            "perimeter method is not defined or not callable",
        )
        perimeter = rect.perimeter()
        _dynamic_test(
            self,
            perimeter == 18,
            "perimeter method returns correct value for (4, 5)",
            f"Expected perimeter 18, got {perimeter}",
        )

    def test_rectangle_other_values(self):
        import user_code
        importlib.reload(user_code)
        Rectangle = getattr(user_code, 'Rectangle', None)
        rect = Rectangle(7, 3)
        area = rect.area()
        perimeter = rect.perimeter()
        _dynamic_test(
            self,
            area == 21,
            "area method returns correct value for (7, 3)",
            f"Expected area 21, got {area}",
        )
        _dynamic_test(
            self,
            perimeter == 20,
            "perimeter method returns correct value for (7, 3)",
            f"Expected perimeter 20, got {perimeter}",
        )

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()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        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] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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


test_main.py

Learn how to build clean, secure, and scalable applications with Object-Oriented Programming in Python. Cover the fundamentals of classes and objects, then moves into advanced concepts such as inheritance, composition, polymorphism, and encapsulation. With clear explanations and practical examples, you'll develop the ability to design Python programs that are powerful, maintainable, and ready for real-world use.

Learn the core building blocks of object-oriented programming in Python. This section covers classes, objects, methods, and variables, giving you a solid base to understand how OOP organizes and structures code.

Challenge: Creating and Using Methods

解答