import unittest
import importlib
import re
import user_code  # Import user's solution

# Helper function for dynamic test naming and assertions
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 test_variables_declared(self):
        """Check if all required variables are declared."""
        variables = ['exercise_time', 'title']
        missing_vars = [var for var in variables if not hasattr(user_code, var)]
        
        _dynamic_test(
            self,
            not missing_vars,
            "All required variables are declared.",
            f"Missing variable(s): {', '.join(missing_vars)}."
        )

    def test_variables_types(self):
        """Check if variables have the correct data types."""
        expected_types = {
            'exercise_time': int,
            'title': str
        }
        incorrect_types = {
            var: type(getattr(user_code, var)) 
            for var in expected_types if not isinstance(getattr(user_code, var), expected_types[var])
        }

        _dynamic_test(
            self,
            not incorrect_types,
            "All variables have the correct data types.",
            f"Incorrect data types detected: {incorrect_types}."
        )

    def test_exercise_time_logic(self):
        """Check if `title` is assigned correctly based on `exercise_time`."""
        exercise_time = user_code.exercise_time

        if exercise_time > 10:
            expected_title = "Super Achiever"
        elif exercise_time >= 6:
            expected_title = "Hard Worker"
        elif exercise_time >= 3:
            expected_title = "Getting There"
        else:
            expected_title = "Needs Improvement"

        _dynamic_test(
            self,
            user_code.title == expected_title,
            f"The `title` variable is correctly set to `{expected_title}`.",
            f"Incorrect value for `title`. Expected `{expected_title}`, but got `{user_code.title}`."
        )

    def test_if_elif_used(self):
        """Check if `if` and `elif` statements are correctly used instead of multiple `if` statements."""
        with open("user_code.py", "r") as file:
            user_code_source = file.read()

        if_statements = re.findall(r'^\s*if\s+', user_code_source, re.MULTILINE)
        elif_statements = re.findall(r'^\s*elif\s+', user_code_source, re.MULTILINE)

        _dynamic_test(
            self,
            len(if_statements) == 1 and len(elif_statements) > 0,
            "The `if-elif` structure is correctly used.",
            "Detected multiple `if` statements instead of a structured `if-elif` chain."
        )

    def test_else_used(self):
        """Check if `else` is correctly used to cover remaining cases."""
        with open("user_code.py", "r") as file:
            user_code_source = file.read()

        else_statements = re.findall(r'^\s*else\s*:', user_code_source, re.MULTILINE)

        _dynamic_test(
            self,
            len(else_statements) == 1,
            "The `else` statement is correctly used.",
            "Expected an `else` statement to handle remaining cases, but none was found."
        )

    def run_with_modified_exercise_time(self, exercise_time_value):
        with open("user_code.py", "r") as file:
            original_code = file.read()

        """Executes the modified user code with a different `exercise_time` value."""
        modified_code = re.sub(r'exercise_time\s*=\s*\d+', f'exercise_time = {exercise_time_value}', original_code)
        local_scope = {}
        exec(modified_code, {}, local_scope)
        return local_scope["title"]

    def test_exercise_time_three(self):
        """Check if `exercise_time = 3` correctly assigns `Getting There`."""
        expected_title = "Getting There"
        result_title = self.run_with_modified_exercise_time(3)

        _dynamic_test(
            self,
            result_title == expected_title,
            "The title is correctly set to `Getting There` when `exercise_time = 3`.",
            f"Incorrect title for `exercise_time = 3`. Expected `{expected_title}`, but got `{result_title}`."
        )

    def test_exercise_time_six(self):
        """Check if `exercise_time = 6` correctly assigns `Hard Worker`."""
        expected_title = "Hard Worker"
        result_title = self.run_with_modified_exercise_time(6)

        _dynamic_test(
            self,
            result_title == expected_title,
            "The title is correctly set to `Hard Worker` when `exercise_time = 6`.",
            f"Incorrect title for `exercise_time = 6`. Expected `{expected_title}`, but got `{result_title}`."
        )

    def test_exercise_time_ten(self):
        """Check if `exercise_time = 10` correctly assigns `Hard Worker`."""
        expected_title = "Hard Worker"
        result_title = self.run_with_modified_exercise_time(10)

        _dynamic_test(
            self,
            result_title == expected_title,
            "The title is correctly set to `Hard Worker` when `exercise_time = 10`.",
            f"Incorrect title for `exercise_time = 10`. Expected `{expected_title}`, but got `{result_title}`."
        )

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

test_main.py

Deze cursus is ontworpen om je kennis te laten maken met alle nuances van de voorwaardelijke operator if-else. De cursus is gevuld met voorbeelden om het gebruik van zo'n operator beter te begrijpen, evenals taken om de verworven vaardigheden te consolideren. Hier maak je ook kennis met de if-elif-else uitspraken.

Je zult de mysteries van de veelzijdige voorwaardelijke operator "if" ontrafelen en de kracht ervan ontdekken om uitkomsten te vormen. Duik dieper in de wereld van logische operatoren, beheers hun kunstzinnige toepassing en ontdek de geheimen van het effectief prioriteren van hun gebruik.

Leer hoe u beslissingen neemt op basis van voorwaarden, code vereenvoudigt met behulp van het else-trefwoord, waardoor zowel de efficiëntie als de leesbaarheid worden verbeterd. Ontgrendel de efficiëntie van eenregelige beslissingen met de ternaire operator!

Je leert over de meest geavanceerde vorm van de voorwaardelijke operator if-elif-else, maakt kennis met de syntaxis van deze constructie en hoe deze correct wordt toegepast.

Uitdaging: Het Bouwen van een Voortgangstracker met Behulp van if-elif-else-Verklaringen

Oplossing

Awesome!

Uitdaging: Het Bouwen van een Voortgangstracker met Behulp van if-elif-else-Verklaringen

Oplossing

Awesome!