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 = ['steps_taken', 'step_goal', 'result_more_than_90']
        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 = {
            'steps_taken': int,
            'step_goal': int,
            'result_more_than_90': bool
        }
        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_result_more_than_90_logic(self):
        """Check if `result_more_than_90` is correctly set based on step goal progress."""
        steps_taken = user_code.steps_taken
        step_goal = user_code.step_goal
        expected_value = steps_taken > step_goal * 0.9

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

    def test_steps_left_calculation(self):
        """Check if `steps_left` is calculated correctly when under 90% of the goal."""
        steps_taken = user_code.steps_taken
        step_goal = user_code.step_goal

        if not user_code.result_more_than_90:
            expected_steps_left = step_goal - steps_taken
            actual_steps_left = getattr(user_code, 'steps_left', None)

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

    def test_if_else_used(self):
        """Check if `if` and `else` are correctly used in the code."""
        with open("user_code.py", "r") as file:
            user_code_source = file.read()

        if_found = re.search(r'^\s*if\s+.*:', user_code_source, re.MULTILINE) is not None
        else_found = re.search(r'^\s*else\s*:', user_code_source, re.MULTILINE) is not None

        _dynamic_test(
            self,
            if_found and else_found,
            "The `if` and `else` statements are correctly used.",
            "Expected both `if` and `else` statements in the code, but one or both are missing."
        )

    def test_if_else_syntax(self):
        """Check if `if` and `else` statements have colons (`:`) at the end."""
        with open("user_code.py", "r") as file:
            user_code_source = file.read()

        missing_colon_if = re.search(r'^\s*if\s+.*[^:]\s*$', user_code_source, re.MULTILINE) is not None
        missing_colon_else = re.search(r'^\s*else\s*[^:]\s*$', user_code_source, re.MULTILINE) is not None

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

    def test_valid_ways_to_write_90_percent_check(self):
        """Ensure the correct mathematical check for 90% is used."""
        with open("user_code.py", "r") as file:
            user_code_source = file.read()

        # Possible valid expressions for checking 90% of the step goal
        valid_expressions = [
            r'steps_taken\s*>\s*step_goal\s*\*\s*0\.9',
            r'steps_taken\s*>\s*0\.9\s*\*\s*step_goal',
            r'steps_taken\s*>\s*step_goal\s*\*\s*$\s*90\s*/\s*100\s*$',
            r'steps_taken\s*>\s*$\s*90\s*/\s*100\s*$\s*\*\s*step_goal'
        ]

        valid_expression_found = any(re.search(pattern, user_code_source) for pattern in valid_expressions)

        _dynamic_test(
            self,
            valid_expression_found,
            "A valid way to check if steps exceed 90% of the goal is used.",
            "Expected a valid mathematical check for 90% of the step goal, but none were found."
        )

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


test_main.py

Dieser Kurs ist darauf ausgelegt, Ihnen alle Nuancen des bedingten Operators if-else vorzustellen. Der Kurs ist mit Beispielen gefüllt, um die Verwendung eines solchen Operators besser zu verstehen, sowie mit Aufgaben, um die erworbenen Fähigkeiten zu festigen. Hier werden Sie auch mit den if-elif-else-Anweisungen vertraut gemacht.

Sie werden die Geheimnisse des vielseitigen bedingten Operators "if" entschlüsseln und seine Kraft entdecken, Ergebnisse zu gestalten. Tauchen Sie tiefer in die Welt der logischen Operatoren ein, meistern Sie deren kunstvolle Anwendung und entdecken Sie die Geheimnisse der effektiven Priorisierung ihrer Nutzung.

Lernen Sie, wie Sie Entscheidungen basierend auf Bedingungen treffen, den Code mit dem else-Schlüsselwort vereinfachen und sowohl Effizienz als auch Lesbarkeit verbessern. Entdecken Sie die Effizienz von einzeiligen Entscheidungen mit dem ternären Operator!

Sie werden die fortschrittlichste Form des bedingten Operators if-elif-else kennenlernen, sich mit der Syntax dieser Konstruktion vertraut machen und erfahren, wie sie korrekt angewendet wird.

Bedingte Anweisungen in Python

Herausforderung: Schrittziel Fortschritt

Lösung

Herausforderung: Schrittziel Fortschritt

Lösung