
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

Leer hoe je schone, veilige en schaalbare applicaties bouwt met objectgeoriënteerd programmeren in Python. Behandel de basisprincipes van klassen en objecten, en ga vervolgens in op geavanceerde concepten zoals overerving, compositie, polymorfisme en encapsulatie. Met duidelijke uitleg en praktische voorbeelden ontwikkel je het vermogen om Python-programma's te ontwerpen die krachtig, onderhoudbaar en klaar zijn voor gebruik in de praktijk.

Leer de kerncomponenten van objectgeoriënteerd programmeren in Python. Deze sectie behandelt klassen, objecten, methoden en variabelen, en biedt een solide basis om te begrijpen hoe OOP code organiseert en structureert.

Challenge: Het Creëren van een Voertuigenhiërarchie

Oplossing