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

Este curso vai ajudá-lo a se aprofundar nos tipos de dados e trabalhar com eles. Aqui você aprenderá operações básicas e todos os detalhes sobre números, tipo de dado booleano e strings. O curso inclui muitas tarefas práticas, após as quais você se tornará um programador habilidoso.

Os tipos de dados numéricos são fundamentais em Python, formando a base de muitas tarefas computacionais. Nesta seção, você explorará os conceitos essenciais para trabalhar com números inteiros e de ponto flutuante, realizar operações matemáticas básicas e compreender as aplicações práticas dos dados numéricos. Você também examinará conceitos críticos como imutabilidade e terá experiência prática com as funções e ferramentas integradas do Python para manipulação eficiente de números.

O principal objetivo desta seção é esclarecer os tipos de dados booleanos; trata-se de um subtipo de dados numéricos, mas de fato é mais desafiador. Como é sempre melhor dominar os tópicos mais difíceis, esta seção é uma parte valiosa do seu currículo.

Strings são uma forma de implementar frases em Python, ou seja, fornecer instruções aos usuários que são o público-alvo do seu programa. De fato, é sempre melhor poder trabalhar com strings, pois elas devem ser utilizadas em seu código. Em breve, você entenderá o motivo.

Alteração de valores para o tipo necessário, limpeza de texto antes de comparações e realização de operações matemáticas apenas com números, formatando os resultados para leitura humana. Marcação clara de dados ausentes e tratamento intencional desses casos, além de distinção entre texto humano e conteúdo bruto de arquivos ou redes. Os objetivos são reduzir erros, garantir comparações confiáveis, obter resultados consistentes e produzir saídas claras e legíveis.


Este capítulo consiste em tarefas práticas que combinam todos os tópicos abordados com um pouco de teoria.

Desafio: Exercícios de Fatiamento e Busca

Solução

Awesome!

Desafio: Exercícios de Fatiamento e Busca

Solução