
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

Erlernen Sie, wie man saubere, sichere und skalierbare Anwendungen mit objektorientierter Programmierung in Python entwickelt. Behandelt werden die Grundlagen von Klassen und Objekten sowie fortgeschrittene Konzepte wie Vererbung, Komposition, Polymorphismus und Kapselung. Mit klaren Erklärungen und praxisnahen Beispielen entwickeln Sie die Fähigkeit, Python-Programme zu entwerfen, die leistungsfähig, wartbar und für den realen Einsatz bereit sind.

Erlernen Sie die grundlegenden Bausteine der objektorientierten Programmierung in Python. Dieser Abschnitt behandelt Klassen, Objekte, Methoden und Variablen und vermittelt eine solide Grundlage, um zu verstehen, wie OOP Code organisiert und strukturiert.

Erkunden Sie, wie Klassen Funktionalitäten teilen und erweitern können. Sie lernen verschiedene Vererbungsmuster kennen, von einfachen Hierarchien bis hin zu Mehrfachvererbung und abstrakten Klassen, und erfahren, wie diese die Wiederverwendbarkeit und Skalierbarkeit von Code ermöglichen.

Erfahren Sie, wie Sie flexible Systeme durch die Kombination von Objekten erstellen. Anstatt sich ausschließlich auf Vererbung zu verlassen, zeigt Ihnen die Komposition, wie Sie Verhaltensweisen modular und anpassungsfähig zusammenstellen können.

Verstehen, wie verschiedene Objekte eine gemeinsame Schnittstelle teilen können, während sie sich unterschiedlich verhalten. Dieser Abschnitt zeigt, wie Methodenüberschreibung, Schnittstellen und Protokolle Ihren Code dynamischer und wiederverwendbarer machen.

Erfahren Sie, wie interne Daten geschützt und der Zugriff auf Klassenattribute kontrolliert werden kann. Sie werden private Attribute, Getter und Setter sowie Techniken zur Datenverbergung kennenlernen, die Ihre Klassen sicher und wartbar halten.

Herausforderung: Entwurf Eines Benachrichtigungssystem-Blueprints

Lösung