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

Hanki vankka ymmärrys Pythonin keskeisistä tietotyypeistä ja opi työskentelemään niiden kanssa tehokkaasti. Tutustu numeroihin, totuusarvoihin ja merkkijonoihin käytännön harjoitusten ja esimerkkien avulla. Rakenna varmuutta perusoperaatioiden suorittamisessa ja kehitä perustaidot, joita tarvitaan selkeän ja tehokkaan Python-koodin kirjoittamiseen.

Tutustu Pythonin numeeristen tietotyyppien perusteisiin ja opi käsittelemään kokonais- ja liukulukuja. Hallitse peruslaskutoimitukset, perehdy muuttumattomuuden käsitteeseen ja saa käytännön kokemusta Pythonin sisäänrakennettujen funktioiden ja työkalujen hyödyntämisestä numeroiden käsittelyssä todellisissa tilanteissa.

Saat selkeän käsityksen Boolean-tietotyypistä, joka on numeerisen datan erikoisalalaji ja edustaa totuusarvoja. Vaikka aihe voi aluksi vaikuttaa haastavalta, Boolean-arvojen hallinta on olennaista loogisten ja tehokkaiden ohjelmien kirjoittamisessa. Tämä osio auttaa soveltamaan Boolean-logiikkaa luottavaisesti käytännön ohjelmointitilanteissa.

Merkkijonot mahdollistavat tekstin käsittelyn Pythonissa, viestien näyttämisestä käyttäjän syötteen käsittelyyn. Tässä osiossa perehdytään merkkijonojen luomiseen, muokkaamiseen ja käsittelyyn tehokkaasti. Merkkijonojen ymmärtäminen on olennaista vuorovaikutteisten ohjelmien kirjoittamisessa ja tiedon selkeässä välittämisessä koodin kautta.

Opi käsittelemään tietotyyppejä tehokkaasti varmistaaksesi ohjelmiesi tarkkuuden ja johdonmukaisuuden. Arvojen muuntaminen sopivaan tyyppiin, tekstin puhdistaminen ennen vertailua sekä numeeristen operaatioiden erottaminen tekstin muotoilusta. Lisäksi opit hallitsemaan puuttuvia tietoja tarkoituksellisesti ja käsittelemään ihmisen luettavaa tekstiä eri tavalla kuin raakadataa, saavuttaen luotettavia, johdonmukaisia ja helposti luettavia tuloksia.

Haaste: Käyttöoikeuden ja Etujen Tarkistaja

Ratkaisu

Awesome!

Haaste: Käyttöoikeuden ja Etujen Tarkistaja

Ratkaisu