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

This course is going to help you dive deeper into data types and try to work with them. Here you will learn basic operations and all ins and outs of numbers, boolean data type, and strings. This course consists of a lot of practical tasks after which you will become a skillful programmer.

Numerical data types are fundamental in Python, forming the backbone of many computational tasks. In this section, you'll dive into the essentials of working with integers and floating-point numbers, performing basic mathematical operations, and understanding the real-world applications of numerical data. You'll also explore critical concepts such as immutability and gain hands-on experience with Python’s built-in functions and tools for handling numbers effectively.

The main goal of this section is to clarify the boolean data types; it's a sub type of numeric data, but indeed it is more challenging. Since it is always better to excel in the more difficult topics, this section is a valuable part of your curriculum.

Strings are a way for us to implement your phrases in Python, that is, to give instructions to users who are the target audience of your program. Indeed, it is always better to be able to work with strings because they should be used in your code. You'll understand why soon.

Change values to the kind you need, clean text before comparing, and keep math strictly with numbers while formatting results for people to read. Mark missing data clearly and handle it on purpose, and treat human text differently from raw file or network content. The goals are fewer mistakes, reliable comparisons, consistent results, and clear, readable output.


This chapter consists of practical tasks that combine all the examined topics together with a bit of theory.

Challenge: Slicing and Search Drills

Ratkaisu

Awesome!

Challenge: Slicing and Search Drills

Ratkaisu

Awesome!