import unittest
import importlib
import re

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.m = importlib.import_module("user_code")
        with open("user_code.py", "r", encoding="utf-8") as f:
            cls.src = f.read()

        # Expected outcomes
        cls.expected_is_adult = 17 >= 21                 # False
        cls.expected_can_enter = cls.expected_is_adult and True  # False
        cls.expected_free_shipping = (120 >= 100) or False       # True
        cls.expected_needs_review = (not True) or (not False)    # True
        cls.expected_valid_range = 0 <= 74 <= 100               # True

    def test_is_adult(self):
        declared = hasattr(self.m, "is_adult")
        is_bool = isinstance(getattr(self.m, "is_adult", None), bool)
        correct = declared and self.m.is_adult == self.expected_is_adult
        pattern = r"is_adult\s*=\s*.*age.*>=.*adult_age"
        _dynamic_test(
            self,
            declared and is_bool and correct and re.search(pattern, self.src),
            "is_adult computed correctly",
            "is_adult computed incorrectly"
        )

    def test_can_enter(self):
        declared = hasattr(self.m, "can_enter")
        is_bool = isinstance(getattr(self.m, "can_enter", None), bool)
        correct = declared and self.m.can_enter == self.expected_can_enter
        pattern = r"can_enter\s*=\s*.*is_adult.*and.*has_id"
        _dynamic_test(
            self,
            declared and is_bool and correct and re.search(pattern, self.src),
            "can_enter computed correctly",
            "can_enter computed incorrectly"
        )

    def test_free_shipping(self):
        declared = hasattr(self.m, "qualifies_free_shipping")
        is_bool = isinstance(getattr(self.m, "qualifies_free_shipping", None), bool)
        correct = declared and self.m.qualifies_free_shipping == self.expected_free_shipping
        pattern = r"qualifies_free_shipping\s*=\s*.*purchase_total.*>=.*free_shipping_threshold.*or.*is_member"
        _dynamic_test(
            self,
            declared and is_bool and correct and re.search(pattern, self.src),
            "qualifies_free_shipping computed correctly",
            "qualifies_free_shipping computed incorrectly"
        )

    def test_needs_manual_review(self):
        declared = hasattr(self.m, "needs_manual_review")
        is_bool = isinstance(getattr(self.m, "needs_manual_review", None), bool)
        correct = declared and self.m.needs_manual_review == self.expected_needs_review
        pattern = r"needs_manual_review\s*=\s*.*not\s*email_verified.*or.*not\s*phone_verified"
        _dynamic_test(
            self,
            declared and is_bool and correct and re.search(pattern, self.src),
            "needs_manual_review computed correctly",
            "needs_manual_review computed incorrectly"
        )

    def test_valid_score_range(self):
        declared = hasattr(self.m, "valid_score_range")
        is_bool = isinstance(getattr(self.m, "valid_score_range", None), bool)
        correct = declared and self.m.valid_score_range == self.expected_valid_range
        pattern = r"min_score.*<=.*score.*<=.*max_score"
        _dynamic_test(
            self,
            declared and is_bool and correct and re.search(pattern, self.src),
            "valid_score_range computed correctly",
            "valid_score_range computed incorrectly"
        )

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

test_main.py

Erwerben Sie ein fundiertes Verständnis der grundlegenden Datentypen von Python und lernen Sie, wie Sie effektiv mit ihnen arbeiten. Untersuchen Sie Zahlen, Boolesche Werte und Zeichenketten anhand praxisnaher Übungen und Beispiele. Stärken Sie Ihre Fähigkeiten bei der Durchführung grundlegender Operationen und entwickeln Sie die notwendigen Grundlagen, um sauberen und effizienten Python-Code zu schreiben.

Entdecken Sie die Grundlagen der numerischen Datentypen in Python und erfahren Sie, wie Sie mit Ganzzahlen und Gleitkommazahlen arbeiten. Beherrschen Sie grundlegende arithmetische Operationen, erkunden Sie das Konzept der Unveränderlichkeit und sammeln Sie praktische Erfahrungen mit den integrierten Funktionen und Werkzeugen von Python, um Zahlen effizient in realen Szenarien zu verarbeiten.

Erhalten Sie ein klares Verständnis des Boolean-Datentyps, einem spezialisierten Subtyp numerischer Daten, der Wahrheitswerte repräsentiert. Obwohl dies zunächst herausfordernd erscheinen mag, ist das Beherrschen von Booleans unerlässlich für das Schreiben logischer und effizienter Programme. Dieser Abschnitt unterstützt Sie dabei, Boolesche Logik sicher in praxisnahen Programmieraufgaben anzuwenden.

Zeichenketten ermöglichen die Arbeit mit Text in Python, vom Anzeigen von Nachrichten bis zur Verarbeitung von Benutzereingaben. Sie werden untersuchen, wie Zeichenketten erstellt, verändert und effektiv manipuliert werden können. Das Verständnis von Zeichenketten ist unerlässlich, um interaktive Programme zu schreiben und Informationen klar durch den Code zu kommunizieren.

Erfahren Sie, wie verschiedene Datentypen effektiv gehandhabt werden, um Genauigkeit und Konsistenz in Programmen sicherzustellen. Werte in den passenden Typ umwandeln, Text vor Vergleichen bereinigen und numerische Operationen von der Textformatierung trennen. Zudem wird gezeigt, wie fehlende Daten gezielt verwaltet und menschenlesbarer Text anders als Rohdaten behandelt werden, um zuverlässige, konsistente und gut lesbare Ergebnisse zu erzielen.

Herausforderung: Zugangs- und Vorteilsprüfer

Lösung

Herausforderung: Zugangs- und Vorteilsprüfer

Lösung