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

class TestTask(unittest.TestCase):
    def test_vehicle_class_exists(self):
        import user_code
        importlib.reload(user_code)
        Vehicle = getattr(user_code, 'Vehicle', None)
        _dynamic_test(
            self,
            Vehicle is not None and isinstance(Vehicle, type),
            "Vehicle class is defined.",
            "Vehicle class is not defined."
        )

    def test_vehicle_init_and_get_info(self):
        import user_code
        importlib.reload(user_code)
        Vehicle = getattr(user_code, 'Vehicle', None)
        v = Vehicle('TestBrand', 77)
        _dynamic_test(
            self,
            hasattr(v, 'brand') and hasattr(v, 'speed'),
            "Vehicle object has brand and speed attributes.",
            "Vehicle object missing brand or speed attributes."
        )
        info = v.get_info()
        _dynamic_test(
            self,
            isinstance(info, str) and 'TestBrand' in info and '77' in info,
            "Vehicle.get_info returns correct string.",
            f"Vehicle.get_info did not return expected string, got: {info}"
        )

    def test_car_class_and_override(self):
        import user_code
        importlib.reload(user_code)
        Car = getattr(user_code, 'Car', None)
        _dynamic_test(
            self,
            Car is not None and isinstance(Car, type),
            "Car class is defined.",
            "Car class is not defined."
        )
        c = Car('Ford', 100, 2)
        _dynamic_test(
            self,
            hasattr(c, 'brand') and hasattr(c, 'speed') and hasattr(c, 'doors'),
            "Car object has brand, speed, and doors attributes.",
            "Car object missing brand, speed, or doors attributes."
        )
        info = c.get_info()
        _dynamic_test(
            self,
            isinstance(info, str) and 'Ford' in info and '100' in info and '2' in info,
            "Car.get_info returns correct string including doors.",
            f"Car.get_info did not return expected string, got: {info}"
        )

    def test_bike_class_and_override(self):
        import user_code
        importlib.reload(user_code)
        Bike = getattr(user_code, 'Bike', None)
        _dynamic_test(
            self,
            Bike is not None and isinstance(Bike, type),
            "Bike class is defined.",
            "Bike class is not defined."
        )
        b = Bike('Trek', 40, 'road')
        _dynamic_test(
            self,
            hasattr(b, 'brand') and hasattr(b, 'speed') and hasattr(b, 'type'),
            "Bike object has brand, speed, and type attributes.",
            "Bike object missing brand, speed, or type attributes."
        )
        info = b.get_info()
        _dynamic_test(
            self,
            isinstance(info, str) and 'Trek' in info and '40' in info and 'road' in info,
            "Bike.get_info returns correct string including type.",
            f"Bike.get_info did not return expected string, got: {info}"
        )

    def test_printed_output(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "brand: generic" in output and "speed: 50" in output,
            "Output includes Vehicle info.",
            f"Vehicle info not found in output: {output}"
        )
        _dynamic_test(
            self,
            "brand: toyota" in output and "speed: 120" in output and "doors: 4" in output,
            "Output includes Car info.",
            f"Car info not found in output: {output}"
        )
        _dynamic_test(
            self,
            "brand: giant" in output and "speed: 30" in output and "type: mountain" in output,
            "Output includes Bike info.",
            f"Bike info not found in output: {output}"
        )

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

Erlernen Sie, wie man saubere, sichere und skalierbare Anwendungen mit objektorientierter Programmierung in Python entwickelt. Behandelt werden die Grundlagen von Klassen und Objekten sowie fortgeschrittene Konzepte wie Vererbung, Komposition, Polymorphismus und Kapselung. Mit klaren Erklärungen und praxisnahen Beispielen entwickeln Sie die Fähigkeit, Python-Programme zu entwerfen, die leistungsfähig, wartbar und für den realen Einsatz bereit sind.

Erlernen Sie die grundlegenden Bausteine der objektorientierten Programmierung in Python. Dieser Abschnitt behandelt Klassen, Objekte, Methoden und Variablen und vermittelt Ihnen eine solide Grundlage, um zu verstehen, wie OOP Code organisiert und strukturiert.

Challenge: Creating a Vehicle Hierarchy

Lösung