import unittest
import importlib
import re

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

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 values
        cls.expected_total = 8 * 9           # 72
        cls.expected_shortfall = 72 - 60     # 12
        cls.expected_completed = 60 // 9     # 6
        cls.expected_unused = 60 % 9         # 6

    def test_total_minutes(self):
        """Validate total_minutes"""
        declared = hasattr(self.m, "total_minutes")
        correct_type = isinstance(getattr(self.m, "total_minutes", None), int)
        correct_value = declared and self.m.total_minutes == self.expected_total
        uses_multiplication = re.search(
            r"total_minutes\s*=\s*.*\*.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_multiplication
        _dynamic_test(
            self,
            all_ok,
            "Total minutes calculated correctly",
            "Total minutes calculated incorrectly"
        )

    def test_shortfall(self):
        """Validate shortfall"""
        declared = hasattr(self.m, "shortfall")
        correct_type = isinstance(getattr(self.m, "shortfall", None), int)
        correct_value = declared and self.m.shortfall == self.expected_shortfall
        uses_subtraction = re.search(
            r"shortfall\s*=\s*.*-.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_subtraction
        _dynamic_test(
            self,
            all_ok,
            "Shortfall calculated correctly",
            "Shortfall calculated incorrectly"
        )

    def test_completed_calls(self):
        """Validate completed_calls"""
        declared = hasattr(self.m, "completed_calls")
        correct_type = isinstance(getattr(self.m, "completed_calls", None), int)
        correct_value = declared and self.m.completed_calls == self.expected_completed
        uses_floor_division = re.search(
            r"completed_calls\s*=\s*.*//.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_floor_division
        _dynamic_test(
            self,
            all_ok,
            "Completed calls calculated correctly",
            "Completed calls calculated incorrectly"
        )

    def test_unused_time(self):
        """Validate unused_time"""
        declared = hasattr(self.m, "unused_time")
        correct_type = isinstance(getattr(self.m, "unused_time", None), int)
        correct_value = declared and self.m.unused_time == self.expected_unused
        uses_modulo = re.search(
            r"unused_time\s*=\s*.*%.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_modulo
        _dynamic_test(
            self,
            all_ok,
            "Unused time calculated correctly",
            "Unused time calculated incorrectly"
        )

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

test_main.py

Gain a solid understanding of Python's core data types and learn how to work with them effectively. Explore numbers, booleans, and strings through hands-on exercises and practical examples. Build confidence in performing basic operations and develop the foundational skills needed to write clean and efficient Python code.

Discover the essentials of numerical data types in Python and learn how to work with integers and floating-point numbers. Master basic arithmetic operations, explore the concept of immutability, and get hands-on experience using Python's built-in functions and tools to handle numbers efficiently in real-world scenarios.

Gain a clear understanding of the Boolean data type, a specialized subtype of numeric data that represents truth values. Although it may seem challenging at first, mastering Booleans is essential for writing logical and efficient programs. This section will help you confidently apply Boolean logic to real-world programming scenarios.

Strings allow you to work with text in Python, from displaying messages to processing user input. You'll explore how to create, modify, and manipulate strings effectively. Understanding strings is essential for writing interactive programs and communicating information clearly through your code.

Learn how to handle data types effectively to ensure accuracy and consistency in your programs. Convert values to the appropriate type, clean text before comparison, and separate numeric operations from text formatting. You'll also discover how to manage missing data deliberately and handle human-readable text differently from raw input, achieving reliable, consistent, and easy-to-read results.

Challenge: Time Calculation

Solution

Awesome!

Challenge: Time Calculation

Solution