import unittest
import importlib

# Helper function
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):

    def setUp(self):
        self.module = importlib.import_module('user_code')
        importlib.reload(self.module)

    # 1. Variable existence
    def test_remaining_tasks_is_declared(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'remaining_tasks'),
            "The `remaining_tasks` variable is declared.",
            "Expected `remaining_tasks` variable to be declared."
        )

    def test_required_time_is_declared(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'required_time'),
            "The `required_time` variable is declared.",
            "Expected `required_time` variable to be declared."
        )

    # 2. Correct types
    def test_remaining_tasks_is_integer(self):
        value = getattr(self.module, 'remaining_tasks', None)
        _dynamic_test(
            self,
            isinstance(value, int),
            "The `remaining_tasks` is of type `int`.",
            "Expected `remaining_tasks` to be of type `int`."
        )

    def test_required_time_is_integer(self):
        value = getattr(self.module, 'required_time', None)
        _dynamic_test(
            self,
            isinstance(value, int),
            "The `required_time` is of type `int`.",
            "Expected `required_time` to be of type `int`."
        )

    # 3. Correct values
    def test_remaining_tasks_correct_value(self):
        completed = 60 // 7
        expected_value = 10 - completed
        actual = getattr(self.module, 'remaining_tasks', None)

        _dynamic_test(
            self,
            actual == expected_value,
            f"The `remaining_tasks` is `{expected_value}`.",
            f"Expected `remaining_tasks` to be `{expected_value}`, but got `{actual}`."
        )

    def test_required_time_correct_value(self):
        expected_value = 10 * 7
        actual = getattr(self.module, 'required_time', None)

        _dynamic_test(
            self,
            actual == expected_value,
            f"The `required_time` is `{expected_value}`.",
            f"Expected `required_time` to be `{expected_value}`, but got `{actual}`."
        )

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


test_main.py

Få en gedigen förståelse för Pythons grundläggande datatyper och lär dig att arbeta effektivt med dem. Utforska tal, booleska värden och strängar genom praktiska övningar och exempel. Bygg upp självförtroende i att utföra grundläggande operationer och utveckla de grundläggande färdigheter som krävs för att skriva ren och effektiv Python-kod.

Upptäck grunderna i numeriska datatyper i Python och lär dig arbeta med heltal och flyttal. Behärska grundläggande aritmetiska operationer, utforska begreppet oföränderlighet och få praktisk erfarenhet av att använda Pythons inbyggda funktioner och verktyg för att hantera nummer effektivt i verkliga situationer.

Få en tydlig förståelse för datatypen bool, en specialiserad undergrupp av numeriska data som representerar sanningsvärden. Även om det kan verka utmanande till en början är det avgörande att behärska booleska värden för att skriva logiska och effektiva program. Detta avsnitt hjälper dig att tillämpa boolesk logik i verkliga programmeringssammanhang med självförtroende.

Strängar gör det möjligt att arbeta med text i Python, från att visa meddelanden till att bearbeta användarinmatning. Du kommer att utforska hur man skapar, modifierar och manipulerar strängar på ett effektivt sätt. Förståelse för strängar är avgörande för att skriva interaktiva program och för att tydligt kommunicera information genom din kod.

Lär dig hantera datatyper effektivt för att säkerställa noggrannhet och konsekvens i dina program. Konvertera värden till lämplig typ, rensa text före jämförelse och separera numeriska operationer från textformatering. Du får även veta hur man hanterar saknade data medvetet och behandlar läsbar text annorlunda än rå indata, vilket ger tillförlitliga, konsekventa och lättlästa resultat.

Utmaning: Tidsberäkning i Python

Lösning