import unittest
import importlib
import re

# Helper function
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):

    def setUp(self):
        self.module = importlib.import_module('user_code')
        importlib.reload(self.module)

    def test_remaining_tasks_is_declared(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'remaining_tasks'),
            "The `remaining_tasks` variable is declared.",
            "Expected `remaining_tasks` variable to be declared."
        )

    def test_required_time_is_declared(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'required_time'),
            "The `required_time` variable is declared.",
            "Expected `required_time` variable to be declared."
        )

    def test_remaining_tasks_is_integer(self):
        _dynamic_test(
            self,
            isinstance(getattr(self.module, 'remaining_tasks', None), int),
            "The `remaining_tasks` is of type `int`.",
            "Expected `remaining_tasks` to be of type `int`."
        )

    def test_required_time_is_integer(self):
        _dynamic_test(
            self,
            isinstance(getattr(self.module, 'required_time', None), int),
            "The `required_time` is of type `int`.",
            "Expected `required_time` to be of type `int`."
        )

    def test_remaining_tasks_correct_value(self):
        completed = 60 // 7
        expected_value = 10 - completed
        _dynamic_test(
            self,
            getattr(self.module, 'remaining_tasks', None) == expected_value,
            f"The `remaining_tasks` is `{expected_value}`.",
            f"Expected `remaining_tasks` to be `{expected_value}`, but got `{getattr(self.module, 'remaining_tasks', 'undefined')}`."
        )

    def test_required_time_correct_value(self):
        expected_value = 10 * 7
        _dynamic_test(
            self,
            getattr(self.module, 'required_time', None) == expected_value,
            f"The `required_time` is `{expected_value}`.",
            f"Expected `required_time` to be `{expected_value}`, but got `{getattr(self.module, 'required_time', 'undefined')}`."
        )

    def test_subtraction_used_for_remaining_tasks(self):
        with open('user_code.py', 'r') as file:
            user_code_source = re.sub(r'\s+', '', file.read())
        _dynamic_test(
            self,
            re.search(r'remaining_tasks=10-[\w_]+', user_code_source),
            "Subtraction is used for `remaining_tasks`.",
            "Expected subtraction to be used for `remaining_tasks`."
        )

    def test_multiplication_used_for_required_time(self):
        with open('user_code.py', 'r') as file:
            user_code_source = re.sub(r'\s+', '', file.read())
        multiplication_patterns = [
            r'required_time=10\*7',
            r'required_time=7\*10'
        ]
        _dynamic_test(
            self,
            any(re.search(pattern, user_code_source) for pattern in multiplication_patterns),
            "Multiplication is used for `required_time`.",
            "Expected multiplication to be used for `required_time` (10*7 or 7*10)."
        )

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

test_main.py

Adquira uma compreensão sólida dos principais tipos de dados do Python e aprenda a utilizá-los de forma eficaz. Explore números, booleanos e strings por meio de exercícios práticos e exemplos aplicados. Desenvolva confiança na execução de operações básicas e construa as habilidades fundamentais necessárias para escrever código Python limpo e eficiente.

Descubra os conceitos essenciais dos tipos de dados numéricos em Python e aprenda a trabalhar com inteiros e números de ponto flutuante. Domine operações aritméticas básicas, explore o conceito de imutabilidade e obtenha experiência prática utilizando as funções e ferramentas integradas do Python para manipular números de forma eficiente em cenários do mundo real.

Obtenha uma compreensão clara do tipo de dado booleano, um subtipo especializado de dados numéricos que representa valores de verdade. Embora possa parecer desafiador no início, dominar booleanos é essencial para escrever programas lógicos e eficientes. Esta seção ajudará você a aplicar com confiança a lógica booleana em cenários de programação do mundo real.

Strings permitem trabalhar com texto em Python, desde exibir mensagens até processar entradas do usuário. Você explorará como criar, modificar e manipular strings de forma eficaz. Compreender strings é essencial para escrever programas interativos e comunicar informações de maneira clara por meio do código.

Aprenda a lidar com tipos de dados de forma eficaz para garantir precisão e consistência em seus programas. Converta valores para o tipo apropriado, limpe textos antes de comparações e separe operações numéricas da formatação de texto. Descubra também como gerenciar dados ausentes de maneira deliberada e tratar textos legíveis por humanos de forma diferente de entradas brutas, alcançando resultados confiáveis, consistentes e de fácil leitura.

Desafio: Cálculo de Tempo em Python

Solução

Awesome!

Desafio: Cálculo de Tempo em Python

Solução