import unittest
import user_code
import importlib
import io
from contextlib import redirect_stdout
import re

class TestTask(unittest.TestCase):
    def test_withdraw_nonlocal_usage(self):
        with open("user_code.py", "r") as f:
            code = f.read()
        _dynamic_test(
            self,
            "nonlocal" in code,
            "The inner function uses 'nonlocal' to modify the balance.",
            "The inner function does not use 'nonlocal' keyword to modify the balance.",
        )

    def test_withdrawal_sequence(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.bank_account()
        output = f.getvalue().strip().splitlines()
        _dynamic_test(
            self,
            len(output) == 3,
            "Three results are printed for three withdrawals.",
            f"Expected 3 output lines, got {len(output)}: {output}",
        )
        try:
            first = int(output[0].strip())
        except Exception:
            _dynamic_test(
                self,
                False,
                "First withdrawal returns new balance as integer.",
                f"First output is not an integer: {output[0]}",
            )
            return
        _dynamic_test(
            self,
            first == 800,
            "Balance after withdrawing 200 is 800.",
            f"Expected 800 after withdrawing 200, got {first}",
        )
        _dynamic_test(
            self,
            output[1].strip().lower().startswith('insufficient'),
            "Second withdrawal shows 'Insufficient funds' message.",
            f"Expected 'Insufficient funds', got: {output[1]}",
        )
        try:
            third = int(output[2].strip())
        except Exception:
            _dynamic_test(
                self,
                False,
                "Third withdrawal returns new balance as integer.",
                f"Third output is not an integer: {output[2]}",
            )
            return
        _dynamic_test(
            self,
            third == 700,
            "Balance after withdrawing 100 is 700.",
            f"Expected 700 after withdrawing 100, got {third}",
        )

    def test_balance_hidden(self):
        # Check that 'balance' is not accessible at module level
        import user_code
        importlib.reload(user_code)
        has_balance = hasattr(user_code, 'balance')
        _dynamic_test(
            self,
            not has_balance,
            "The balance variable is not accessible outside the outer function.",
            "The balance variable should not be accessible outside the outer 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)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    # Not used in this test
    return code


test_main.py

In this course, you will learn advanced topics such as function arguments, iterators, generators, closures, and decorators. Dozens of practice exercises will help you grasp these topics.

Explore the art of packing and unpacking lists, tuples, and dictionaries to write more expressive and efficient Python code.

Delve into the world of higher-order functions, passing functions as arguments, and writing concise anonymous functions with lambda.

Unravel the mysteries of variable scope, and learn how nested functions and closures enable powerful encapsulation.

Delve into Python's iteration protocol, custom iterators, and generator functions for efficient data processing.

Challenge: Modifying Enclosing Scope Variables

Oplossing