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

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 grundlegend und bilden das Rückgrat vieler Rechenaufgaben. In diesem Abschnitt werden die Grundlagen der Arbeit mit Ganzzahlen und Gleitkommazahlen behandelt, grundlegende mathematische Operationen durchgeführt und die praktischen Anwendungen numerischer Daten erläutert. Zudem werden wichtige Konzepte wie Unveränderlichkeit vorgestellt und praktische Erfahrungen mit den integrierten Funktionen und Werkzeugen von Python zur effektiven Handhabung von Zahlen vermittelt.

Das Hauptziel dieses Abschnitts ist die Klärung der booleschen Datentypen; sie sind eine Unterart der numerischen Daten, stellen jedoch eine größere Herausforderung dar. Da es immer besser ist, in schwierigeren Themen zu glänzen, ist dieser Abschnitt ein wertvoller Bestandteil Ihres Lehrplans.

Zeichenketten ermöglichen es, Ausdrücke in Python zu implementieren, also Anweisungen für die Zielgruppe Ihres Programms bereitzustellen. Es ist grundsätzlich vorteilhaft, mit Zeichenketten zu arbeiten, da sie in Ihrem Code verwendet werden sollten. Die Gründe dafür werden Sie bald verstehen.

Werte in den benötigten Typ umwandeln, Text vor dem Vergleichen bereinigen und mathematische Operationen ausschließlich mit Zahlen durchführen, während Ergebnisse für die Lesbarkeit formatiert werden. Fehlende Daten eindeutig kennzeichnen und gezielt behandeln sowie menschlichen Text anders behandeln als rohe Datei- oder Netzwerkdaten. Die Ziele sind weniger Fehler, zuverlässige Vergleiche, konsistente Ergebnisse und eine klare, lesbare Ausgabe.


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

Herausforderung: Zeitberechnung

Lösung

Awesome!

Herausforderung: Zeitberechnung

Lösung