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',
            r'step_goal\s*\*\s0\.9\s*<=\s*steps_taken',
            r'0\.9\s*\*\s*step_goal\s*<=\s*steps_taken',
            r'steps_taken\s*>=\s*step_goal\s*\*\s*\.9',
        ]

        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 comparison for 90% of the step goal using '>=' or '<=', but found strict operators like '>' or '<' instead."
        )

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


test_main.py

Dette kurset er designet for å introdusere deg for alle nyansene ved den betingede operatøren if-else. Kurset er fylt med eksempler for bedre å forstå bruken av en slik operatør, samt oppgaver for å konsolidere de tilegnede ferdighetene. Her vil du også bli kjent med if-elif-else utsagnene.

Du vil avdekke mysteriene til den allsidige betingelsesoperatøren "if," og oppdage dens kraft til å forme utfall. Dykk dypere inn i verdenen av logiske operatører, mestre deres kunstneriske anvendelse og avdekke hemmelighetene ved å prioritere deres bruk effektivt.

Lær hvordan du tar beslutninger basert på betingelser, forenkler koden ved å bruke else-nøkkelordet, og forbedrer både effektivitet og lesbarhet. Lås opp effektiviteten av enlinjers beslutninger med den ternære operatoren!

Du vil lære om den mest avanserte formen for den betingede operatøren if-elif-else, bli kjent med syntaksen til denne konstruksjonen og hvordan den brukes riktig.

Utfordring: Sporing av Fremgang mot Skrittmål med If-Else-setninger

Løsning

Awesome!

Utfordring: Sporing av Fremgang mot Skrittmål med If-Else-setninger

Løsning