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 values based on the challenge setup
        cls.expected_total_required = 10 * 7     # 70
        cls.expected_shortfall = cls.expected_total_required - 60   # 10
        cls.expected_total_hours = cls.expected_total_required / 60 # 70/60
        cls.expected_completed = 60 // 7         # 8
        cls.expected_unused = 60 % 7             # 4

    def test_shortfall_minutes_group(self):
        """
        One message validating EVERYTHING about `shortfall_minutes`:
        - declared, int, correct value (10)
        - source uses `total_required - available_minutes`
        - and `total_required` is computed via `num_calls * avg_minutes_per_call`
        """
        declared = hasattr(self.m, 'shortfall_minutes')
        correct_type = isinstance(getattr(self.m, 'shortfall_minutes', None), int)
        correct_value = declared and (self.m.shortfall_minutes == self.expected_shortfall)

        # shortfall_minutes: uses subtraction
        uses_subtraction = re.search(
            r"""shortfall_minutes\s*=\s*[^#\n]*total_required[^#\n]*-[^#\n]*available_minutes""",
            self.src
        ) is not None

        total_required_from_vars = re.search(
            r"""total_required\s*=\s*[^#\n]*num_calls[^#\n]*\*[^#\n]*avg_minutes_per_call""", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_subtraction and total_required_from_vars
        _dynamic_test(
            self,
            all_ok,
            "Minutes you are short computed correctly",
            "Minutes you are short computed incorrectly"
        )

    def test_total_hours_group(self):
        """
        One message validating EVERYTHING about `total_hours`:
        - declared, float, correct value (70/60)
        - source uses `total_required / minutes_in_hour`
        """
        declared = hasattr(self.m, 'total_hours')
        correct_type = isinstance(getattr(self.m, 'total_hours', None), float)
        correct_value = declared and abs(self.m.total_hours - self.expected_total_hours) < 1e-9

        # total_hours: uses division
        uses_division = re.search(
            r"""total_hours\s*=\s*[^#\n]*total_required[^#\n]*/[^#\n]*minutes_in_hour""",
            self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_division
        _dynamic_test(
            self,
            all_ok,
            "Total duration in hours for all calls computed correctly",
            "Total duration in hours for all calls computed incorrectly"
        )

    def test_completed_calls_group(self):
        """
        One message validating EVERYTHING about `completed_calls`:
        - declared, int, correct value (8)
        - source uses floor division: `available_minutes // avg_minutes_per_call`
        """
        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)

        # completed_calls: uses floor division //
        uses_floor_div = re.search(
            r"""completed_calls\s*=\s*[^#\n]*available_minutes[^#\n]*//[^#\n]*avg_minutes_per_call""",
            self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_floor_div
        _dynamic_test(
            self,
            all_ok,
            "Completed calls within available time computed correctly",
            "Completed calls within available time computed incorrectly"
        )

    def test_unused_minutes_group(self):
        """
        One message validating EVERYTHING about `unused_minutes`:
        - declared, int, correct value (4)
        - source uses modulo: `available_minutes % avg_minutes_per_call`
        """
        declared = hasattr(self.m, 'unused_minutes')
        correct_type = isinstance(getattr(self.m, 'unused_minutes', None), int)
        correct_value = declared and (self.m.unused_minutes == self.expected_unused)

        # unused_minutes: uses modulo %
        uses_modulo = re.search(
            r"""unused_minutes\s*=\s*[^#\n]*available_minutes[^#\n]*%[^#\n]*avg_minutes_per_call""",
            self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_modulo
        _dynamic_test(
            self,
            all_ok,
            "Unused minutes within available time computed correctly",
            "Unused minutes within available time computed incorrectly"
        )

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


test_main.py

Deze cursus helpt je dieper in te gaan op gegevenstypen en ermee te werken. Hier leer je basisbewerkingen en alle ins en outs van getallen, het booleaanse gegevenstype en strings. De cursus bevat veel praktische opdrachten waarna je een vaardige programmeur wordt.

Numerieke gegevenstypen zijn fundamenteel in Python en vormen de basis van veel computationele taken. In deze sectie verdiept u zich in de essentie van het werken met gehele getallen en drijvende-kommagetallen, het uitvoeren van basis wiskundige bewerkingen en het begrijpen van de toepassingen van numerieke gegevens in de praktijk. U verkent tevens belangrijke concepten zoals onveranderlijkheid en doet praktische ervaring op met de ingebouwde functies en hulpmiddelen van Python voor het effectief omgaan met getallen.

Het belangrijkste doel van deze sectie is het verduidelijken van de booleaanse gegevenstypen; het is een subtype van numerieke gegevens, maar het is inderdaad uitdagender. Aangezien het altijd beter is om uit te blinken in de moeilijkere onderwerpen, vormt deze sectie een waardevol onderdeel van het curriculum.

Strings zijn een manier om zinnen te implementeren in Python, oftewel om instructies te geven aan gebruikers die de doelgroep van je programma vormen. Het is inderdaad altijd beter om met strings te werken, omdat deze in je code gebruikt moeten worden. Je zult snel begrijpen waarom.

Waarden omzetten naar het gewenste type, tekst opschonen vóór vergelijking en wiskundige bewerkingen uitsluitend met getallen uitvoeren, terwijl resultaten worden geformatteerd voor leesbaarheid. Ontbrekende gegevens duidelijk markeren en bewust verwerken, en menselijke tekst anders behandelen dan ruwe bestands- of netwerkgegevens. De doelen zijn minder fouten, betrouwbare vergelijkingen, consistente resultaten en duidelijke, leesbare output.


Dit hoofdstuk bestaat uit praktische opdrachten die alle behandelde onderwerpen combineren met een beetje theorie.

Uitdaging: Tijdsberekening

Oplossing

Awesome!

Uitdaging: Tijdsberekening

Oplossing