
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import types

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

    def test_notifier_is_abstract(self):
        Notifier = getattr(self.user_code, 'Notifier', None)
        _dynamic_test(
            self,
            Notifier is not None and hasattr(Notifier, '__abstractmethods__') and 'send' in Notifier.__abstractmethods__,
            "Notifier is an abstract base class with abstract method 'send'",
            "Notifier class is missing or does not have abstract method 'send'"
        )

    def test_email_notifier_inherits(self):
        EmailNotifier = getattr(self.user_code, 'EmailNotifier', None)
        Notifier = getattr(self.user_code, 'Notifier', None)
        _dynamic_test(
            self,
            EmailNotifier is not None and Notifier is not None and issubclass(EmailNotifier, Notifier),
            "EmailNotifier correctly inherits from Notifier",
            "EmailNotifier does not inherit from Notifier"
        )

    def test_sms_notifier_inherits(self):
        SMSNotifier = getattr(self.user_code, 'SMSNotifier', None)
        Notifier = getattr(self.user_code, 'Notifier', None)
        _dynamic_test(
            self,
            SMSNotifier is not None and Notifier is not None and issubclass(SMSNotifier, Notifier),
            "SMSNotifier correctly inherits from Notifier",
            "SMSNotifier does not inherit from Notifier"
        )

    def test_email_notifier_send(self):
        EmailNotifier = getattr(self.user_code, 'EmailNotifier', None)
        _dynamic_test(
            self,
            EmailNotifier is not None,
            "EmailNotifier class is defined",
            "EmailNotifier class is missing"
        )
        email = EmailNotifier()
        result = email.send("Test message")
        _dynamic_test(
            self,
            isinstance(result, str) and result.startswith("Email sent:"),
            "EmailNotifier.send returns correct string format",
            f"EmailNotifier.send returned: {result}"
        )

    def test_sms_notifier_send(self):
        SMSNotifier = getattr(self.user_code, 'SMSNotifier', None)
        _dynamic_test(
            self,
            SMSNotifier is not None,
            "SMSNotifier class is defined",
            "SMSNotifier class is missing"
        )
        sms = SMSNotifier()
        result = sms.send("Test message")
        _dynamic_test(
            self,
            isinstance(result, str) and result.startswith("SMS sent:"),
            "SMSNotifier.send returns correct string format",
            f"SMSNotifier.send returned: {result}"
        )

    def test_notify_user_polymorphism(self):
        notify_user = getattr(self.user_code, 'notify_user', None)
        EmailNotifier = getattr(self.user_code, 'EmailNotifier', None)
        SMSNotifier = getattr(self.user_code, 'SMSNotifier', None)
        _dynamic_test(
            self,
            notify_user is not None,
            "notify_user function is defined",
            "notify_user function is missing"
        )
        email = EmailNotifier()
        sms = SMSNotifier()
        email_result = notify_user(email, "Welcome!")
        sms_result = notify_user(sms, "Your code is 1234.")
        _dynamic_test(
            self,
            isinstance(email_result, str) and email_result.startswith("Email sent:"),
            "notify_user works with EmailNotifier",
            f"notify_user(EmailNotifier, ...) returned: {email_result}"
        )
        _dynamic_test(
            self,
            isinstance(sms_result, str) and sms_result.startswith("SMS sent:"),
            "notify_user works with SMSNotifier",
            f"notify_user(SMSNotifier, ...) returned: {sms_result}"
        )

    def test_example_usage(self):
        # Check that the example usage variables exist and are correct types
        email_notifier = getattr(self.user_code, 'email_notifier', None)
        sms_notifier = getattr(self.user_code, 'sms_notifier', None)
        notify_user = getattr(self.user_code, 'notify_user', None)
        _dynamic_test(
            self,
            email_notifier is not None and sms_notifier is not None,
            "Example usage objects are defined",
            "email_notifier or sms_notifier is missing"
        )
        result_email = notify_user(email_notifier, "Welcome!")
        result_sms = notify_user(sms_notifier, "Your code is 1234.")
        _dynamic_test(
            self,
            isinstance(result_email, str) and result_email.startswith("Email sent:"),
            "email_notifier works with notify_user",
            f"email_notifier with notify_user returned: {result_email}"
        )
        _dynamic_test(
            self,
            isinstance(result_sms, str) and result_sms.startswith("SMS sent:"),
            "sms_notifier works with notify_user",
            f"sms_notifier with notify_user returned: {result_sms}"
        )

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. Dette afsnit dækker klasser, objekter, metoder og variabler og giver dig et solidt fundament for at forstå, hvordan OOP organiserer og strukturerer kode.

Undersøg, hvordan klasser kan dele og udvide funktionalitet. Du lærer om forskellige arvmønstre, fra simple hierarkier til multipel arv og abstrakte klasser, og ser, hvordan de muliggør genbrug af kode og skalerbarhed.

Opdag, hvordan man opbygger fleksible systemer ved at kombinere objekter. I stedet for udelukkende at benytte arv, viser vi, hvordan komposition gør det muligt at samle funktionaliteter på en modulær og tilpasningsdygtig måde.

Forstå hvordan forskellige objekter kan dele et fælles interface, men opføre sig på deres egen måde. Dette afsnit viser, hvordan metodeoverskrivning, interfaces og protokoller gør din kode mere dynamisk og genanvendelig.

Lær at beskytte interne data og kontrollere adgangen til klasseattributter. Du vil udforske private attributter, getters og setters samt teknikker til dataindkapsling, der gør dine klasser sikre og vedligeholdelsesvenlige.

Udfordring: Oprettelse af Blueprint for Notifikationssystem

Løsning