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

class TestTask(unittest.TestCase):
    def test_constructor_and_attributes(self):
        import user_code
        importlib.reload(user_code)
        s = user_code.Sensor("S1", [1, 2, 3])
        _dynamic_test(
            self,
            hasattr(s, 'sensor_id') and s.sensor_id == "S1",
            "sensor_id is set correctly in constructor",
            f"Expected sensor_id to be 'S1', got {getattr(s, 'sensor_id', None)}"
        )
        _dynamic_test(
            self,
            hasattr(s, 'readings') and isinstance(s.readings, list) and s.readings == [1, 2, 3],
            "readings is set correctly in constructor",
            f"Expected readings to be [1, 2, 3], got {getattr(s, 'readings', None)}"
        )

    def test_constructor_default_readings(self):
        import user_code
        importlib.reload(user_code)
        s = user_code.Sensor("S2")
        _dynamic_test(
            self,
            hasattr(s, 'readings') and s.readings == [],
            "Default readings is an empty list",
            f"Expected readings to be [], got {getattr(s, 'readings', None)}"
        )

    def test_add_reading(self):
        import user_code
        importlib.reload(user_code)
        s = user_code.Sensor("S3")
        s.add_reading(5)
        s.add_reading(8)
        _dynamic_test(
            self,
            s.readings == [5, 8],
            "add_reading appends values correctly",
            f"Expected readings to be [5, 8], got {s.readings}"
        )

    def test_average_reading(self):
        import user_code
        importlib.reload(user_code)
        s = user_code.Sensor("S4", [10, 20, 30])
        avg = s.average_reading()
        _dynamic_test(
            self,
            abs(avg - 20.0) < 1e-8,
            "average_reading returns correct average",
            f"Expected average 20.0, got {avg}"
        )

    def test_average_reading_empty(self):
        import user_code
        importlib.reload(user_code)
        s = user_code.Sensor("S5")
        avg = s.average_reading()
        _dynamic_test(
            self,
            avg is None,
            "average_reading returns None for empty readings",
            f"Expected None for empty readings, got {avg}"
        )

    def test_reset_readings(self):
        import user_code
        importlib.reload(user_code)
        s = user_code.Sensor("S6", [1, 2, 3])
        s.reset_readings()
        _dynamic_test(
            self,
            s.readings == [],
            "reset_readings empties the readings list",
            f"Expected readings to be [], got {s.readings}"
        )

    def test_instance_independence(self):
        import user_code
        importlib.reload(user_code)
        s1 = user_code.Sensor("S7")
        s2 = user_code.Sensor("S8")
        s1.add_reading(100)
        _dynamic_test(
            self,
            s1.readings == [100] and s2.readings == [],
            "Each Sensor instance maintains independent readings",
            f"Expected s1.readings = [100], s2.readings = [], got {s1.readings}, {s2.readings}"
        )

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()


Challenge: Creating the Sensor

Solution