import unittest
import importlib
import re

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)

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 values
        cls.exp_age = 19
        cls.exp_has_id = True
        cls.exp_tier = "VIP"
        cls.exp_seat_number_str = "023"
        cls.exp_zone = "A"
        cls.exp_seat_number = 23
        cls.exp_is_adult = True
        cls.exp_can_enter = True
        cls.exp_vip_perk = True
        cls.exp_member_fastlane = False
        cls.exp_seat_ok = True
        cls.exp_entry_granted = True
        cls.exp_summary = f"{cls.exp_tier}-{cls.exp_seat_number_str}-{cls.exp_zone} | age={cls.exp_age} | enter={cls.exp_entry_granted} | vip={cls.exp_vip_perk} | fastlane={cls.exp_member_fastlane}"

    def test_conversions(self):
        ok = hasattr(self.m, "age") and hasattr(self.m, "has_id")
        type_ok = ok and isinstance(self.m.age, int) and isinstance(self.m.has_id, bool)
        val_ok = ok and self.m.age == self.exp_age and self.m.has_id == self.exp_has_id
        pat_age = re.search(r'''int\s*\(\s*age_str\s*\.\s*strip\s*\(\s*\)\s*\)''', self.src)
        pat_hasid = re.search(r'''casefold\s*\(\s*\)\s*==\s*["']yes["']''', self.src)
        _dynamic_test(self, type_ok and val_ok and pat_age and pat_hasid,
                      "age and ID conversions correct", "age and ID conversions incorrect")

    def test_ticket_parts(self):
        ok = all(hasattr(self.m, v) for v in ["tier", "seat_number_str", "zone", "seat_number"])
        val_ok = ok and self.m.tier == self.exp_tier and self.m.seat_number_str == self.exp_seat_number_str and self.m.zone == self.exp_zone and self.m.seat_number == self.exp_seat_number
        pat_tier = re.search(r'''ticket_code\s*\[\s*:\s*3\s*\]''', self.src)
        pat_num = re.search(r'''ticket_code\s*\[\s*4\s*:\s*7\s*\]''', self.src)
        pat_zone = re.search(r'''ticket_code\s*\[\s*-1\s*\]''', self.src)
        pat_int = re.search(r'''int\s*\(\s*seat_number_str\s*\)''', self.src)
        _dynamic_test(self, val_ok and pat_tier and pat_num and pat_zone and pat_int,
                      "ticket parts parsed correctly", "ticket parts parsed incorrectly")

    def test_rules(self):
        names = ["is_adult", "can_enter", "vip_perk", "member_fastlane", "seat_ok", "entry_granted"]
        ok = all(hasattr(self.m, n) for n in names)
        val_ok = (
            ok and
            self.m.is_adult == self.exp_is_adult and
            self.m.can_enter == self.exp_can_enter and
            self.m.vip_perk == self.exp_vip_perk and
            self.m.member_fastlane == self.exp_member_fastlane and
            self.m.seat_ok == self.exp_seat_ok and
            self.m.entry_granted == self.exp_entry_granted
        )
        patterns = [
            r'''age\s*>=\s*adult_age''',
            r'''has_id\s*and\s*is_adult''',
            r'''tier\s*==\s*["']VIP["']''',
            r'''is_member\s*and\s*can_enter''',
            r'''1\s*<=\s*seat_number\s*<=\s*max_seat_number''',
            r'''can_enter\s*and\s*seat_ok'''
        ]
        _dynamic_test(self, val_ok and all(re.search(p, self.src) for p in patterns),
                      "rules computed correctly", "rules computed incorrectly")

    def test_summary(self):
        ok = hasattr(self.m, "summary") and self.m.summary == self.exp_summary
        pat = re.search(r'''f["']\{tier\}-\{seat_number_str\}-\{zone\}.*\{age\}.*\{entry_granted\}.*\{vip_perk\}.*\{member_fastlane\}["']''', self.src)
        _dynamic_test(self, ok and pat, "summary computed correctly", "summary computed incorrectly")

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

test_code.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 erikoistyyppi ja edustaa totuusarvoja. Vaikka aihe voi aluksi vaikuttaa haastavalta, Boolean-arvojen hallinta on olennaista loogisten ja tehokkaiden ohjelmien kirjoittamisessa. Tämä osio auttaa sinua soveltamaan Boolean-logiikkaa luottavaisesti todellisissa 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.
Numeraalisten operaatioiden erottaminen tekstin muotoilusta.
Puuttuvien tietojen hallinta tarkoituksellisesti.
Ihmisten luettavaksi tarkoitetun tekstin käsittely eri tavalla kuin raakasyötteen.
Luotettavien, johdonmukaisten ja helposti luettavien tulosten saavuttaminen.

Haaste: Pääsy- ja Lippuetujen Moottori

Ratkaisu

Haaste: Pääsy- ja Lippuetujen Moottori

Ratkaisu