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

Få en solid forståelse av Pythons grunnleggende datatyper og lær hvordan du arbeider effektivt med dem. Utforsk tall, boolske verdier og strenger gjennom praktiske øvelser og eksempler. Bygg selvtillit i å utføre grunnleggende operasjoner og utvikle de nødvendige ferdighetene for å skrive ryddig og effektiv Python-kode.

Oppdag det grunnleggende om numeriske datatyper i Python og lær hvordan du arbeider med heltall og flyttall. Få oversikt over grunnleggende aritmetiske operasjoner, utforsk begrepet uforanderlighet, og få praktisk erfaring med Pythons innebygde funksjoner og verktøy for effektiv håndtering av tall i virkelige situasjoner.

Få en tydelig forståelse av den boolske datatypen, en spesialisert undertype av numeriske data som representerer sannhetsverdier. Selv om det kan virke utfordrende i starten, er det avgjørende å beherske boolske verdier for å skrive logiske og effektive programmer. Denne delen vil hjelpe deg å anvende boolsk logikk trygt i virkelige programmeringssituasjoner.

Strenger lar deg arbeide med tekst i Python, fra å vise meldinger til å behandle brukerinput. Du vil utforske hvordan du oppretter, endrer og manipulerer strenger på en effektiv måte. Forståelse av strenger er avgjørende for å skrive interaktive programmer og formidle informasjon tydelig gjennom koden din.

Lær hvordan du håndterer datatyper effektivt for å sikre nøyaktighet og konsistens i programmene dine. Konverter verdier til riktig type, rens tekst før sammenligning, og skill mellom numeriske operasjoner og tekstformatering. Du vil også oppdage hvordan du bevisst håndterer manglende data og behandler menneskelesbar tekst annerledes enn rå input, for å oppnå pålitelige, konsistente og lettleste resultater.

Utfordring: Tilgangs- og Fordelskontroll

Løsning

Awesome!

Utfordring: Tilgangs- og Fordelskontroll

Løsning