
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_add_task_inserts(self):
        import user_code
        importlib.reload(user_code)
        tasks = []
        user_code.add_task(tasks, "Do laundry")
        _dynamic_test(
            self,
            tasks == ["Do laundry"],
            "add_task adds a task to the list",
            f"Expected ['Do laundry'], got {tasks}",
        )

    def test_remove_existing_task(self):
        import user_code
        importlib.reload(user_code)
        tasks = ["A", "B", "C"]
        user_code.remove_task(tasks, "B")
        _dynamic_test(
            self,
            tasks == ["A", "C"],
            "remove_task removes an existing task",
            f"Expected ['A', 'C'], got {tasks}",
        )

    def test_remove_nonexistent_task(self):
        import user_code
        importlib.reload(user_code)
        tasks = ["A", "B"]
        try:
            user_code.remove_task(tasks, "X")
            no_error = True
        except Exception:
            no_error = False
        _dynamic_test(
            self,
            no_error and tasks == ["A", "B"],
            "remove_task does not error or change list if task not found",
            f"Expected ['A', 'B'] and no error, got {tasks}",
        )

    def test_print_tasks_prints_current_list(self):
        import user_code
        importlib.reload(user_code)
        tasks = ["Buy groceries", "Call the bank", "Walk the dog"]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_tasks(tasks)
        output = normalize_text(f.getvalue())
        expected = normalize_text(str(tasks))
        _dynamic_test(
            self,
            expected in output,
            f"print_tasks prints the current list: {expected}",
            f"Expected output: '{expected}' not found in: {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: To-Do List Organizer

Lösung