
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_sum_of_expenses(self):
        import user_code
        importlib.reload(user_code)
        expenses = [10, 20, 30]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_expenses(expenses)
        output = f.getvalue()
        _dynamic_test(
            self,
            "total expenses: 60" in normalize_text(output),
            "Correct sum is printed for expenses [10, 20, 30]",
            f"Expected 'total expenses: 60' in output, got: {output}",
        )

    def test_average_of_expenses(self):
        import user_code
        importlib.reload(user_code)
        expenses = [5, 10, 15]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_expenses(expenses)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "average expense: 10.0" in output,
            "Correct average is printed for expenses [5, 10, 15]",
            f"Expected 'average expense: 10.0' in output, got: {output}",
        )

    def test_highest_expense(self):
        import user_code
        importlib.reload(user_code)
        expenses = [3, 12, 7, 25, 8]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_expenses(expenses)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "highest expense: 25" in output,
            "Correct highest value is printed for expenses [3, 12, 7, 25, 8]",
            f"Expected 'highest expense: 25' in output, got: {output}",
        )

    def test_empty_expenses(self):
        import user_code
        importlib.reload(user_code)
        expenses = []
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_expenses(expenses)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "total expenses: 0" in output,
            "Correct output for total on empty expenses list",
            f"Expected 'total expenses: 0' in output, got: {output}",
        )
        _dynamic_test(
            self,
            "average expense: 0" in output,
            "Correct output for average on empty expenses list",
            f"Expected 'average expense: 0' in output, got: {output}",
        )
        _dynamic_test(
            self,
            "highest expense: 0" in output,
            "Correct output for highest on empty expenses list",
            f"Expected 'highest expense: 0' in output, got: {output}",
        )

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: Simple Expense Analyzer

Solution