
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_lists_are_separated(self):
        import user_code
        importlib.reload(user_code)
        a = [1, 2, 3]
        b = a
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.add_item_to_lists(a, b, 42)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "target list: [1, 2, 3, 42]" in output and "other list: [1, 2, 3]" in output,
            "Correctly prints separated lists when input variables reference the same object.",
            f"Output did not correctly separate lists when input was the same object: {output}",
        )

    def test_lists_are_already_separate(self):
        import user_code
        importlib.reload(user_code)
        a = [1, 2, 3]
        b = [1, 2, 3]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.add_item_to_lists(a, b, 77)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "target list: [1, 2, 3, 77]" in output and "other list: [1, 2, 3]" in output,
            "Correctly prints lists when input variables are already separate.",
            f"Output did not correctly print lists when input variables were already separate: {output}",
        )

    def test_lists_different_values(self):
        import user_code
        importlib.reload(user_code)
        a = [5, 6]
        b = [7, 8]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.add_item_to_lists(a, b, 100)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "target list: [5, 6, 100]" in output and "other list: [7, 8]" in output,
            "Correctly prints lists with different initial values.",
            f"Output did not correctly print lists with different values: {output}",
        )

    def test_side_effect_on_other_list(self):
        import user_code
        importlib.reload(user_code)
        a = [1, 2]
        b = a
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.add_item_to_lists(a, b, 9)
        # After the function, b should remain unchanged
        _dynamic_test(
            self,
            b == [1, 2],
            "Function did not mutate other_list when both lists referenced the same object.",
            f"other_list was mutated: {b}",
        )

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()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    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] = []
                    
                    return '\\n'.join(lines)
    return code

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


test_main.py

A practical course designed to help learners identify, understand, and fix frequent mistakes made by Python programmers. Through real-world examples and hands-on tasks, students will develop the skills to debug, refactor, and write more robust Python code.

Explore the most frequent syntax and indentation mistakes in Python, understand their causes, and learn strategies to avoid them.

Identify and resolve common mistakes related to variable naming, assignment, and scope in Python.

Uncover frequent logical mistakes, including off-by-one errors, improper comparisons, and boolean logic mishaps.

Investigate mistakes related to mutable default arguments, object references, and unintended side effects in Python functions.

Challenge: Reference Fixer

Soluzione

Awesome!

Challenge: Reference Fixer

Soluzione