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

Dieser Kurs hilft Ihnen, tiefer in Datentypen einzutauchen und mit ihnen zu arbeiten. Hier lernen Sie grundlegende Operationen sowie alle Details zu Zahlen, dem booleschen Datentyp und Zeichenketten. Der Kurs enthält zahlreiche praktische Aufgaben, nach deren Abschluss Sie ein versierter Programmierer sein werden.

Numerische Datentypen sind in Python von zentraler Bedeutung, daher ist es wichtig, mit ihnen zu beginnen. In diesem Abschnitt werden einfache mathematische Operationen behandelt und die Gründe für das Erlernen verschiedener numerischer Datentypen erläutert.

Beherrschung von booleschen Datentypen und logischen Operationen in Python. Sie lernen, wie mit True und False gearbeitet wird, wie logische Operatoren wie and, or und not angewendet werden und wie die Operatorrangfolge in komplexen Ausdrücken funktioniert.

Zeichenketten sind ein wesentlicher Bestandteil der Python-Programmierung und ermöglichen die Arbeit mit Textdaten. In diesem Abschnitt lernen Sie, wie Zeichenketten manipuliert, Zeichen extrahiert, Wörter geschnitten und nach bestimmten Ausdrücken gesucht werden.

Dieses Kapitel besteht aus praktischen Aufgaben, die alle behandelten Themen mit etwas Theorie verbinden.

Challenge: Time Calculation in Python

Lösung

Awesome!

Challenge: Time Calculation in Python

Lösung

Awesome!