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

class TestTask(unittest.TestCase):
    def test_total_expenses_and_balance(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.calculate_budget(3500, 1200, 400, 150, 100, 200, 250)
        _dynamic_test(
            self,
            isinstance(result, tuple) and len(result) == 2,
            "Function returns a tuple with two elements",
            f"Expected tuple with two elements, got {result}",
        )
        total_expenses, remaining_balance = result
        _dynamic_test(
            self,
            total_expenses == 1200 + 400 + 150 + 100 + 200 + 250,
            "Total expenses calculated correctly",
            f"Expected total expenses 2300, got {total_expenses}",
        )
        _dynamic_test(
            self,
            remaining_balance == 3500 - 2300,
            "Remaining balance calculated correctly",
            f"Expected remaining balance 1200, got {remaining_balance}",
        )

    def test_all_expenses_zero(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.calculate_budget(1500, 0, 0, 0, 0, 0, 0)
        _dynamic_test(
            self,
            result == (0, 1500),
            "Works with zero expenses",
            f"Expected (0, 1500), got {result}",
        )

    def test_income_equals_expenses(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.calculate_budget(500, 100, 100, 100, 100, 50, 50)
        _dynamic_test(
            self,
            result == (500, 0),
            "Works when income equals total expenses",
            f"Expected (500, 0), got {result}",
        )

    def test_negative_income(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.calculate_budget(-100, 10, 10, 10, 10, 10, 10)
        _dynamic_test(
            self,
            result == (60, -160),
            "Works with negative income",
            f"Expected (60, -160), got {result}",
        )

    def test_zero_income(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.calculate_budget(0, 1, 2, 3, 4, 5, 6)
        _dynamic_test(
            self,
            result == (21, -21),
            "Works with zero income",
            f"Expected (21, -21), got {result}",
        )

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:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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


test_main.py

Master practical Python skills for everyday tasks, from calculations and data organization to visualizing information and automating routines. This course blends engaging theory with hands-on challenges, empowering you to solve real-world problems efficiently using Python.

Learn to use Python for automating calculations and streamlining daily routines, from budgeting to simple reminders.

Discover how Python can help you organize, analyze, and summarize everyday data, from to-do lists to simple statistics.

Learn to create simple visualizations and formatted outputs to communicate information clearly and effectively.

Challenge: Personal Budget Calculator

Oplossing

Challenge: Personal Budget Calculator

Oplossing