import unittest
import importlib
import re
import io
import contextlib


class TestTask(unittest.TestCase):
    def test_classes_exist(self):
        import user_code
        importlib.reload(user_code)

        Weapon = getattr(user_code, "Weapon", None)
        Warrior = getattr(user_code, "Warrior", None)

        _dynamic_test(
            self,
            Weapon is not None and Warrior is not None,
            "Weapon and Warrior classes exist",
            "Weapon and Warrior classes missing",
        )

    def test_weapon_init(self):
        import user_code
        importlib.reload(user_code)

        Weapon = getattr(user_code, "Weapon", None)
        sword = Weapon("Sword", 5)

        _dynamic_test(
            self,
            hasattr(sword, "name") and hasattr(sword, "attack"),
            "Weapon has name and attack attributes",
            "Weapon missing name or attack attribute",
        )
        _dynamic_test(
            self,
            sword.name == "Sword" and sword.attack == 5,
            "Weapon stores name and attack correctly",
            f"Expected ('Sword', 5), got ({getattr(sword,'name',None)}, {getattr(sword,'attack',None)})",
        )

    def test_warrior_init(self):
        import user_code
        importlib.reload(user_code)

        Warrior = getattr(user_code, "Warrior", None)
        w = Warrior("Conan")

        _dynamic_test(
            self,
            hasattr(w, "name") and w.name == "Conan",
            "Warrior stores name correctly",
            "Warrior missing name or stores it incorrectly",
        )
        _dynamic_test(
            self,
            hasattr(w, "weapon") and w.weapon is None,
            "Warrior starts unarmed (weapon is None)",
            "Warrior weapon should start as None",
        )

    def test_equip_weapon_composition(self):
        import user_code
        importlib.reload(user_code)

        Weapon = getattr(user_code, "Weapon", None)
        Warrior = getattr(user_code, "Warrior", None)

        sword = Weapon("Sword", 5)
        w = Warrior("Conan")
        w.equip_weapon(sword)

        _dynamic_test(
            self,
            hasattr(w, "weapon") and w.weapon is sword,
            "Warrior equips weapon via composition",
            "Weapon not equipped correctly (should store the same object)",
        )

    def test_show_weapon_output_unarmed(self):
        import user_code
        importlib.reload(user_code)

        Warrior = getattr(user_code, "Warrior", None)
        w = Warrior("Conan")

        out = _capture_print(w.show_weapon)
        expected = normalize_text("Conan is unarmed")

        _dynamic_test(
            self,
            normalize_text(out) == expected,
            "show_weapon prints unarmed message",
            f"Expected '{expected}', got '{normalize_text(out)}'",
        )

    def test_show_weapon_output_armed(self):
        import user_code
        importlib.reload(user_code)

        Weapon = getattr(user_code, "Weapon", None)
        Warrior = getattr(user_code, "Warrior", None)

        sword = Weapon("Sword", 5)
        w = Warrior("Conan")
        w.equip_weapon(sword)

        out = _capture_print(w.show_weapon)
        expected = normalize_text("Conan is holding a Sword")

        _dynamic_test(
            self,
            normalize_text(out) == expected,
            "show_weapon prints armed message",
            f"Expected '{expected}', got '{normalize_text(out)}'",
        )


def _capture_print(func, *args, **kwargs) -> str:
    buf = io.StringIO()
    with contextlib.redirect_stdout(buf):
        func(*args, **kwargs)
    return buf.getvalue().strip()


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: str) -> str:
    text = text.strip().lower()
    text = re.sub(r"\s{2,}", " ", text)
    return text


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

test_main.py

Lär dig att bygga rena, säkra och skalbara applikationer med objektorienterad programmering i Python. Täck grunderna i klasser och objekt, och gå sedan vidare till avancerade koncept såsom arv, komposition, polymorfism och inkapsling. Med tydliga förklaringar och praktiska exempel utvecklar du förmågan att designa Python-program som är kraftfulla, underhållbara och redo för verklig användning.

Lär dig de grundläggande byggstenarna i objektorienterad programmering i Python. Detta avsnitt behandlar klasser, objekt, metoder och variabler, vilket ger en stabil grund för att förstå hur OOP organiserar och strukturerar kod.

Utforska hur klasser kan dela och utöka funktionalitet. Du kommer att lära dig olika arvsmönster, från enkla hierarkier till multipelt arv och abstrakta klasser, och se hur dessa möjliggör återanvändning av kod och skalbarhet.

Upptäck hur du bygger flexibla system genom att kombinera objekt. Istället för att enbart förlita dig på arv, visar vi hur komposition gör det möjligt att sammanfoga beteenden på ett modulärt och anpassningsbart sätt.

Förstå hur olika objekt kan dela ett gemensamt gränssnitt men ändå uppträda på sitt eget sätt. Detta avsnitt visar hur metodöverskuggning, gränssnitt och protokoll gör din kod mer dynamisk och återanvändbar.

Lär dig hur du skyddar intern data och kontrollerar åtkomst till klassattribut. Du kommer att utforska privata attribut, getters och setters samt tekniker för att dölja data som håller dina klasser säkra och underhållbara.

Utmaning: Bygga en Sammansatt Krigare

Lösning