
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

Aprenda a construir aplicações limpas, seguras e escaláveis com Programação Orientada a Objetos em Python. Aborde os fundamentos de classes e objetos, avançando para conceitos avançados como herança, composição, polimorfismo e encapsulamento. Com explicações claras e exemplos práticos, você desenvolverá a capacidade de projetar programas Python poderosos, manuteníveis e prontos para uso no mundo real.

Aprenda os principais fundamentos da programação orientada a objetos em Python. Esta seção aborda classes, objetos, métodos e variáveis, proporcionando uma base sólida para compreender como a OOP organiza e estrutura o código.

Explore como as classes podem compartilhar e estender funcionalidades. Você aprenderá diferentes padrões de herança, desde hierarquias simples até herança múltipla e classes abstratas, e verá como eles possibilitam o reuso de código e a escalabilidade.

Descubra como construir sistemas flexíveis combinando objetos. Em vez de depender apenas de herança, veja como a composição permite montar comportamentos de forma modular e adaptável.

Compreenda como diferentes objetos podem compartilhar uma interface comum enquanto apresentam comportamentos distintos. Esta seção demonstra como a sobrescrita de métodos, interfaces e protocolos tornam seu código mais dinâmico e reutilizável.

Aprenda a proteger dados internos e controlar o acesso aos atributos de classe. Serão explorados atributos privados, métodos getters e setters, e técnicas de ocultação de dados que mantêm suas classes seguras e fáceis de manter.

Desafio: Criando uma Hierarquia de Veículos

Solução