
import unittest
import user_code
import ast
import re   
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_all_cases_inclusive(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'filter_and_label', None)
        _dynamic_test(
            self,
            callable(func),
            "Function filter_and_label is defined",
            "Function filter_and_label is missing or not callable"
        )
        # Test with range boundaries and outside
        result = func([9, 10, 15, 20, 21])
        expected = [
            (9, 'out of range'),
            (10, 'in range'),
            (15, 'in range'),
            (20, 'in range'),
            (21, 'out of range'),
        ]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly labels numbers at and outside range boundaries.",
            f"Expected {expected}, got {result}"
        )

    def test_in_range_middle(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'filter_and_label', None)
        result = func([11, 12, 19])
        expected = [
            (11, 'in range'),
            (12, 'in range'),
            (19, 'in range'),
        ]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly labels numbers strictly within the range.",
            f"Expected {expected}, got {result}"
        )

    def test_all_out_of_range(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'filter_and_label', None)
        result = func([1, 5, 25, 100])
        expected = [
            (1, 'out of range'),
            (5, 'out of range'),
            (25, 'out of range'),
            (100, 'out of range'),
        ]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly labels numbers all outside the range.",
            f"Expected {expected}, got {result}"
        )

    def test_empty_list(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'filter_and_label', None)
        result = func([])
        expected = []
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly handles empty list input.",
            f"Expected {expected}, 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()
    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: Mixed Logic and Range

解答