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

Opnå en solid forståelse af Pythons grundlæggende datatyper og lær at arbejde effektivt med dem. Udforsk tal, booleans og strenge gennem praktiske øvelser og eksempler. Opbyg selvtillid i udførelsen af basale operationer og udvikl de grundlæggende færdigheder, der er nødvendige for at skrive ren og effektiv Python-kode.

Opdag det grundlæggende om numeriske datatyper i Python, og lær at arbejde med heltal og flydende kommatal. Få styr på grundlæggende aritmetiske operationer, udforsk begrebet uforanderlighed, og få praktisk erfaring med Pythons indbyggede funktioner og værktøjer til effektiv håndtering af tal i virkelige situationer.

Opnå en klar forståelse af datatypen Boolean, en specialiseret undertype af numeriske data, der repræsenterer sandhedsværdier. Selvom det kan virke udfordrende i starten, er det afgørende at mestre Booleans for at skrive logiske og effektive programmer. Dette afsnit vil hjælpe dig med sikkert at anvende Boolean-logik i virkelige programmeringssituationer.

Strenge gør det muligt at arbejde med tekst i Python, fra visning af beskeder til behandling af brugerinput. Du vil undersøge, hvordan man opretter, ændrer og manipulerer strenge effektivt. Forståelse af strenge er afgørende for at skrive interaktive programmer og formidle information tydeligt gennem din kode.

Lær at håndtere datatyper effektivt for at sikre nøjagtighed og konsistens i dine programmer. Konverter værdier til den passende type, rens tekst før sammenligning, og adskil numeriske operationer fra tekstformatering. Du vil også opdage, hvordan man håndterer manglende data bevidst og behandler menneskelæsbar tekst anderledes end rå input, hvilket giver pålidelige, konsistente og letlæselige resultater.

Udfordring: Adgangs- og Fordelstjekker

Løsning