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 results from fixed inputs
        cls.exp_name_clean = "Ada Lovelace"
        cls.exp_has_quick = True
        cls.exp_inside_parens = "quick"
        cls.exp_o_count = 4
        cls.exp_id_prefix = "USR"
        cls.exp_id_number = "00042"
        cls.exp_id_suffix = "xy"
        cls.exp_domain = "example.com"
        cls.exp_report = f"{cls.exp_name_clean} | {cls.exp_domain} | {cls.exp_id_number} | {cls.exp_o_count}"

    # 1) name_clean group
    def test_name_clean_group(self):
        declared = hasattr(self.m, 'name_clean')
        correct = declared and (self.m.name_clean == self.exp_name_clean)
        pattern = r"""name_clean\s*=\s*full_name\s*\.\s*strip\s*\(\s*\)"""
        used_strip = re.search(pattern, self.src, re.DOTALL) is not None
        _dynamic_test(
            self,
            declared and correct and used_strip,
            "name_clean computed correctly",
            "name_clean computed incorrectly"
        )

    # 2) has_quick + o_count group (content checks)
    def test_content_checks_group(self):
        has_q_decl = hasattr(self.m, 'has_quick')
        oc_decl = hasattr(self.m, 'o_count')
        has_q_val = has_q_decl and (self.m.has_quick == self.exp_has_quick)
        oc_val = oc_decl and (self.m.o_count == self.exp_o_count)

        pat_has_quick = r"""has_quick\s*=\s*target_word\s+in\s+sentence\s*\.\s*lower\s*\(\s*\)"""
        pat_o_count = r"""o_count\s*=\s*sentence\s*\.\s*lower\s*\(\s*\)\s*\.\s*count\s*\(\s*'o'\s*\)"""
        ok_has_quick = re.search(pat_has_quick, self.src, re.DOTALL) is not None
        ok_o_count = re.search(pat_o_count, self.src, re.DOTALL) is not None

        _dynamic_test(
            self,
            has_q_decl and oc_decl and has_q_val and oc_val and ok_has_quick and ok_o_count,
            "content checks computed correctly",
            "content checks computed incorrectly"
        )

    # 3) inside_parens group
    def test_inside_parens_group(self):
        declared = hasattr(self.m, 'inside_parens')
        correct = declared and (self.m.inside_parens == self.exp_inside_parens)

        pat_left = r"""left\s*=\s*sentence\s*\.\s*find\s*\(\s*LPAREN\s*\)"""
        pat_right = r"""right\s*=\s*sentence\s*\.\s*find\s*\(\s*RPAREN\s*\)"""
        pat_slice = r"""inside_parens\s*=\s*sentence\s*\[\s*left\s*\+\s*1\s*:\s*right\s*\]"""
        ok_left = re.search(pat_left, self.src, re.DOTALL) is not None
        ok_right = re.search(pat_right, self.src, re.DOTALL) is not None
        ok_slice = re.search(pat_slice, self.src, re.DOTALL) is not None

        _dynamic_test(
            self,
            declared and correct and ok_left and ok_right and ok_slice,
            "inside_parens computed correctly",
            "inside_parens computed incorrectly"
        )

    # 4) id parts group
    def test_id_parts_group(self):
        pre = hasattr(self.m, 'id_prefix') and hasattr(self.m, 'id_number') and hasattr(self.m, 'id_suffix')
        vals = pre and (self.m.id_prefix == self.exp_id_prefix) and (self.m.id_number == self.exp_id_number) and (self.m.id_suffix == self.exp_id_suffix)

        pat_pre = r"""id_prefix\s*=\s*id_code\s*\[\s*:\s*3\s*\]"""
        pat_num = r"""id_number\s*=\s*id_code\s*\[\s*4\s*:\s*9\s*\]"""
        pat_suf = r"""id_suffix\s*=\s*id_code\s*\[\s*-2\s*:\s*\]"""
        ok_pre = re.search(pat_pre, self.src, re.DOTALL) is not None
        ok_num = re.search(pat_num, self.src, re.DOTALL) is not None
        ok_suf = re.search(pat_suf, self.src, re.DOTALL) is not None

        _dynamic_test(
            self,
            pre and vals and ok_pre and ok_num and ok_suf,
            "id parts computed correctly",
            "id parts computed incorrectly"
        )

    # 5) domain group
    def test_domain_group(self):
        declared = hasattr(self.m, 'domain') and hasattr(self.m, 'email_clean') and hasattr(self.m, 'domain_at')
        correct = declared and (self.m.domain == self.exp_domain)

        pat_clean = r"""email_clean\s*=\s*email\s*\.\s*strip\s*\(\s*\)\s*\.\s*lower\s*\(\s*\)"""
        pat_find = r"""domain_at\s*=\s*email_clean\s*\.\s*find\s*\(\s*AT\s*\)"""
        pat_dom = r"""domain\s*=\s*email_clean\s*\[\s*domain_at\s*\+\s*1\s*:\s*\]"""
        ok_clean = re.search(pat_clean, self.src, re.DOTALL) is not None
        ok_find = re.search(pat_find, self.src, re.DOTALL) is not None
        ok_dom = re.search(pat_dom, self.src, re.DOTALL) is not None

        _dynamic_test(
            self,
            declared and correct and ok_clean and ok_find and ok_dom,
            "domain computed correctly",
            "domain computed incorrectly"
        )

    # 6) report group
    def test_report_group(self):
        declared = hasattr(self.m, 'report')
        correct = declared and (self.m.report == self.exp_report)

        # Minimal check: an f-string is used and references required fields
        pat = r"""report\s*=\s*f["'].*\{name_clean\}.*\{SEP\}.*\{domain\}.*\{SEP\}.*\{id_number\}.*\{SEP\}.*\{o_count\}["']"""
        used_f = re.search(pat, self.src, re.DOTALL) is not None

        _dynamic_test(
            self,
            declared and correct and used_f,
            "report computed correctly",
            "report computed incorrectly"
        )

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


test_code.py

Deze cursus helpt je dieper in te gaan op gegevenstypen en ermee te werken. Hier leer je basisbewerkingen en alle ins en outs van getallen, het booleaanse gegevenstype en strings. De cursus bevat veel praktische opdrachten waarna je een vaardige programmeur wordt.

Numerieke gegevenstypen zijn fundamenteel in Python en vormen de basis van veel computationele taken. In deze sectie verdiept u zich in de essentie van het werken met gehele getallen en drijvende-kommagetallen, het uitvoeren van basis wiskundige bewerkingen en het begrijpen van de toepassingen van numerieke gegevens in de praktijk. U verkent tevens belangrijke concepten zoals onveranderlijkheid en doet praktische ervaring op met de ingebouwde functies en hulpmiddelen van Python voor het effectief omgaan met getallen.

Het belangrijkste doel van deze sectie is het verduidelijken van de booleaanse gegevenstypen; het is een subtype van numerieke gegevens, maar het is inderdaad uitdagender. Aangezien het altijd beter is om uit te blinken in de moeilijkere onderwerpen, vormt deze sectie een waardevol onderdeel van het curriculum.

Strings zijn een manier om zinnen te implementeren in Python, oftewel om instructies te geven aan gebruikers die de doelgroep van je programma vormen. Het is inderdaad altijd beter om met strings te werken, omdat deze in je code gebruikt moeten worden. Je zult snel begrijpen waarom.

Waarden omzetten naar het gewenste type, tekst opschonen vóór vergelijking en wiskundige bewerkingen uitsluitend met getallen uitvoeren, terwijl resultaten worden geformatteerd voor leesbaarheid. Ontbrekende gegevens duidelijk markeren en bewust verwerken, en menselijke tekst anders behandelen dan ruwe bestands- of netwerkgegevens. De doelen zijn minder fouten, betrouwbare vergelijkingen, consistente resultaten en duidelijke, leesbare output.


Dit hoofdstuk bestaat uit praktische opdrachten die alle behandelde onderwerpen combineren met een beetje theorie.

Uitdaging: Oefeningen met Slicing en Zoeken

Oplossing

Awesome!

Uitdaging: Oefeningen met Slicing en Zoeken

Oplossing