import unittest
import re

# Read the original user code
with open("user_code.py", "r") as file:
    original_code = file.read()

# 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 run_with_modified_workout_duration(self, duration_value):
        modified_code = re.sub(r'workout_duration\s*=\s*\d+', f'workout_duration = {duration_value}', original_code)
        local_scope = {}
        exec(modified_code, {}, local_scope)
        return local_scope["message"]

    def test_variables_declared(self):
        """Check if all required variables are declared."""
        variables = ['workout_duration', 'message']
        missing_vars = [var for var in variables if var not in original_code]
        
        _dynamic_test(
            self,
            not missing_vars,
            "All required variables are declared.",
            f"Missing variable(s): {', '.join(missing_vars)}."
        )

    def test_workout_duration_70(self):
        """Check message for `workout_duration = 70`."""
        duration = 70
        expected_message = "Excellent job! You've worked out for over an hour!"
        result_message = self.run_with_modified_workout_duration(duration)
    
        _dynamic_test(
            self,
            result_message == expected_message,
            f"The message is correctly set for `workout_duration = {duration}`.",
            f"Incorrect message for `workout_duration = {duration}`. Expected `{expected_message}`, but got `{result_message}`."
        )
    
    def test_workout_duration_60(self):
        """Check message for `workout_duration = 60`."""
        duration = 60
        expected_message = "Great job! Keep it up!"
        result_message = self.run_with_modified_workout_duration(duration)
    
        _dynamic_test(
            self,
            result_message == expected_message,
            f"The message is correctly set for `workout_duration = {duration}`.",
            f"Incorrect message for `workout_duration = {duration}`. Expected `{expected_message}`, but got `{result_message}`."
        )
    
    def test_workout_duration_45(self):
        """Check message for `workout_duration = 45`."""
        duration = 45
        expected_message = "Great job! Keep it up!"
        result_message = self.run_with_modified_workout_duration(duration)
    
        _dynamic_test(
            self,
            result_message == expected_message,
            f"The message is correctly set for `workout_duration = {duration}`.",
            f"Incorrect message for `workout_duration = {duration}`. Expected `{expected_message}`, but got `{result_message}`."
        )
    
    def test_workout_duration_30(self):
        """Check message for `workout_duration = 30`."""
        duration = 30
        expected_message = "Great job! Keep it up!"
        result_message = self.run_with_modified_workout_duration(duration)
    
        _dynamic_test(
            self,
            result_message == expected_message,
            f"The message is correctly set for `workout_duration = {duration}`.",
            f"Incorrect message for `workout_duration = {duration}`. Expected `{expected_message}`, but got `{result_message}`."
        )
    
    def test_workout_duration_25(self):
        """Check message for `workout_duration = 25`."""
        duration = 25
        expected_message = "Try to aim for at least 30 minutes of exercise."
        result_message = self.run_with_modified_workout_duration(duration)
    
        _dynamic_test(
            self,
            result_message == expected_message,
            f"The message is correctly set for `workout_duration = {duration}`.",
            f"Incorrect message for `workout_duration = {duration}`. Expected `{expected_message}`, but got `{result_message}`."
        )

    def test_if_elif_used(self):
        """Check if `if` and `elif` statements are correctly used instead of multiple `if` statements."""
        if_statements = re.findall(r'^\s*if\s*', original_code, re.MULTILINE)
        elif_statements = re.findall(r'^\s*elif\s*', original_code, 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."""
        else_statements = re.findall(r'^\s*else\s*:', original_code, 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 test_if_elif_else_syntax(self):
        """Check if `if`, `elif`, and `else` statements have colons (`:`) at the end."""
        missing_colon_if = re.search(r'^\s*if\s*.*[^:]\s*$', original_code, re.MULTILINE) is not None
        missing_colon_elif = re.search(r'^\s*elif\s*.*[^:]\s*$', original_code, re.MULTILINE) is not None
        missing_colon_else = re.search(r'^\s*else\s*[^:]\s*$', original_code, re.MULTILINE) is not None

        _dynamic_test(
            self,
            not (missing_colon_if or missing_colon_elif or missing_colon_else),
            "All `if`, `elif`, and `else` statements have proper syntax with colons (`:`).",
            "Syntax error detected: An `if`, `elif`, or `else` statement is missing a colon (`:`)."
        )

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: Implementeren van een Workout Duur Tracker met if-elif-else

Oplossing