"""独立示例：注解不校验；使用 unittest 固化边界行为。"""
import unittest
import sys
from typing import Protocol


def bad_double(value: int) -> int:
    return value * 2


def parse_limit(raw: object) -> int:
    # 先确认文本与长度，避免扫描明显过长的输入。
    if type(raw) is not str:
        raise ValueError("limit must contain ASCII decimal digits")
    if len(raw) > 3:
        raise ValueError("limit is too long")
    if not raw.isascii() or not raw.isdecimal():
        raise ValueError("limit must contain ASCII decimal digits")
    value = int(raw)
    if not 1 <= value <= 100:
        raise ValueError("limit must be between 1 and 100")
    return value


class LimitTests(unittest.TestCase):
    def test_valid_boundaries(self):
        for raw, expected in [("1", 1), ("100", 100), ("007", 7)]:
            with self.subTest(raw=raw):
                self.assertEqual(parse_limit(raw), expected)

    def test_invalid_inputs(self):
        for raw in [None, True, 1, "", "0", "101", "-1", " 1", "１", "9999"]:
            with self.subTest(raw=raw):
                with self.assertRaises(ValueError):
                    parse_limit(raw)

    def test_annotation_is_not_validation(self):
        self.assertEqual(bad_double("3"), "33")

    def test_structural_reader(self):
        class Reader(Protocol):
            def read(self) -> str: ...

        class MemoryReader:
            def read(self) -> str:
                return "INFO boot"

        def first_level(reader: Reader) -> str:
            return reader.read().split(" ", 1)[0]

        self.assertEqual(first_level(MemoryReader()), "INFO")

    def test_annotation_evaluation_boundary(self):
        namespace = {"events": []}
        source = (
            "def mark():\n"
            "    events.append('annotation evaluated')\n"
            "    return int\n"
            "def annotated(value: mark()):\n"
            "    return value\n"
        )
        exec(compile(source, "<trusted-annotation-example>", "exec"), namespace)
        before_read = len(namespace["events"])
        # 只读取自己定义的可信注解，绝不读取外部不可信表达式。
        self.assertIs(namespace["annotated"].__annotations__["value"], int)
        self.assertEqual(len(namespace["events"]), 1)
        self.assertEqual(before_read, 0 if sys.version_info >= (3, 14) else 1)
        print("annotation events before/after read:", before_read, len(namespace["events"]))


if __name__ == "__main__":
    print("annotation-only:", bad_double("3"))
    unittest.main()
