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

Tämä kurssi auttaa sinua syventymään tietotyyppeihin ja työskentelemään niiden kanssa. Opit täällä perusoperaatiot sekä kaikki numerotyyppien, totuusarvotyyppien ja merkkijonojen yksityiskohdat. Kurssi sisältää runsaasti käytännön tehtäviä, joiden jälkeen sinusta tulee taitava ohjelmoija.

Numeeriset tietotyypit ovat keskeisiä Pythonissa ja muodostavat monien laskennallisten tehtävien perustan. Tässä osiossa perehdyt kokonaislukujen ja liukulukujen käsittelyn perusteisiin, suoritat peruslaskutoimituksia ja ymmärrät numeerisen datan käytännön sovelluksia. Lisäksi tutustut keskeisiin käsitteisiin, kuten muuttumattomuuteen, ja saat käytännön kokemusta Pythonin sisäänrakennetuista funktioista ja työkaluista numeroiden käsittelyyn tehokkaasti.

Tämän osion päätavoitteena on selventää boolean-tietotyyppejä; se on numeerisen datan alatyyppi, mutta todellisuudessa haastavampi. Koska vaativimmissa aiheissa menestyminen on aina hyödyllistä, tämä osio on arvokas osa opintokokonaisuuttasi.

Merkkijonot ovat tapa toteuttaa lauseita Pythonissa, eli antaa ohjeita ohjelmasi kohdeyleisölle. Onkin aina parempi osata käsitellä merkkijonoja, sillä niitä tulisi käyttää koodissasi. Syyt tähän selviävät pian.

Muunna arvot tarvittavaan tietotyyppiin, puhdista teksti ennen vertailua ja pidä laskutoimitukset vain numeroiden välillä, muotoillen tulokset luettaviksi. Merkitse puuttuvat tiedot selkeästi ja käsittele ne tarkoituksella, sekä käsittele ihmisten kirjoittamaa tekstiä eri tavalla kuin raakaa tiedosto- tai verkkosisältöä. Tavoitteena on vähentää virheitä, varmistaa luotettavat vertailut, tuottaa johdonmukaisia tuloksia ja selkeää, helposti luettavaa tulostetta.


Tämä luku sisältää käytännön tehtäviä, jotka yhdistävät kaikki käsitellyt aiheet sekä hieman teoriaa.

Haaste: Ajan Laskeminen

Ratkaisu

Awesome!

Haaste: Ajan Laskeminen

Ratkaisu