
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

Lær at bygge rene, sikre og skalerbare applikationer med objektorienteret programmering i Python. Dækker grundlæggende principper for klasser og objekter og går derefter videre til avancerede emner som arv, komposition, polymorfi og indkapsling. Med klare forklaringer og praktiske eksempler udvikler du evnen til at designe Python-programmer, der er kraftfulde, vedligeholdelsesvenlige og klar til brug i virkelige situationer.

Lær de grundlæggende byggesten i objektorienteret programmering i Python. Denne sektion dækker klasser, objekter, metoder og variabler og giver dig et solidt fundament for at forstå, hvordan OOP organiserer og strukturerer kode.

Challenge: Creating a Vehicle Hierarchy

Løsning