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

Questo corso ti aiuterà ad approfondire i tipi di dati e a lavorare con essi. Qui imparerai le operazioni di base e tutti gli aspetti relativi ai numeri, al tipo di dato booleano e alle stringhe. Il corso include numerosi esercizi pratici che ti permetteranno di diventare un programmatore esperto.

I tipi di dati numerici sono fondamentali in Python e costituiscono la base di molte operazioni computazionali. In questa sezione verranno trattati gli elementi essenziali per lavorare con numeri interi e numeri in virgola mobile, l'esecuzione di operazioni matematiche di base e la comprensione delle applicazioni pratiche dei dati numerici. Verranno inoltre esplorati concetti chiave come l'immutabilità e si acquisirà esperienza pratica con le funzioni e gli strumenti integrati di Python per la gestione efficace dei numeri.

L'obiettivo principale di questa sezione è chiarire i tipi di dati booleani; si tratta di un sottoinsieme dei dati numerici, ma risulta effettivamente più complesso. Poiché è sempre meglio eccellere negli argomenti più difficili, questa sezione rappresenta una parte preziosa del tuo curriculum.

Le stringhe sono un modo per implementare frasi in Python, ovvero per fornire istruzioni agli utenti che sono il pubblico di destinazione del programma. In effetti, è sempre preferibile poter lavorare con le stringhe poiché dovrebbero essere utilizzate nel codice. Presto sarà chiaro il motivo.

Convertire i valori al tipo necessario, pulire il testo prima di confrontarlo e mantenere i calcoli esclusivamente tra numeri, formattando i risultati per una facile lettura. Segnalare chiaramente i dati mancanti e gestirli intenzionalmente, trattando il testo umano in modo diverso rispetto ai contenuti grezzi di file o rete. Gli obiettivi sono ridurre gli errori, garantire confronti affidabili, ottenere risultati coerenti e produrre output chiari e leggibili.


Questo capitolo consiste in esercizi pratici che combinano tutti gli argomenti esaminati insieme a un po' di teoria.

Sfida: Calcolo del Tempo

Soluzione

Awesome!

Sfida: Calcolo del Tempo

Soluzione