pm3py/tests/test_rawcli.py

"""rawcli Phase 1 — session state, breadcrumb, trace rendering, CLI dispatch. Hardware-free."""
import re

from unittest.mock import MagicMock

import pytest

from pm3py.cli.main import build_parser, main
from pm3py.cli.rawcli.session import RawSession
from pm3py.cli.rawcli.trace_view import render_exchange
from pm3py.cli.rawcli.parser import parse_token, parse_bytes, parse_line
from pm3py.cli.rawcli.entry import byte_space
from pm3py.cli.rawcli.identify import identify, clear, name_14a, format_summary
from pm3py.cli.rawcli.catalog import TYPE2, ISO15, T5577, LF_READONLY, catalog_for, catalog_for as _cf
from pm3py.cli.rawcli.tlv import parse_tlv, format_tlv
from pm3py.cli.rawcli.completer import RawCompleter
from pm3py.cli.rawcli.app import dispatch

_ANSI = re.compile(r"\x1b\[[0-9;]*m")


def _plain(s: str) -> str:
    return _ANSI.sub("", s)


class TestBreadcrumb:
    def test_default(self):
        assert RawSession().breadcrumb() == "[raw / 0x]"

    def test_toggle_to_binary(self):
        s = RawSession()
        assert s.toggle_entry_mode() == "bin"
        assert s.entry_prefix == "0b"
        assert s.breadcrumb() == "[raw / 0b]"
        assert s.toggle_entry_mode() == "hex"
        assert s.breadcrumb() == "[raw / 0x]"

    def test_identified_fills_segments(self):
        s = RawSession()
        s.field = "hf"
        s.transponder = "NTAG215"
        assert s.breadcrumb() == "[raw / hf / NTAG215 / 0x]"

    def test_field_only(self):
        s = RawSession()
        s.field = "lf"
        assert s.breadcrumb() == "[raw / lf / 0x]"

    def test_colored_matches_plain(self):
        s = RawSession()
        s.field, s.transponder = "hf", "NTAG213"
        assert "\x1b[" in s.colored_breadcrumb()               # actually colored
        assert _plain(s.colored_breadcrumb()) == s.breadcrumb()  # same content, ANSI stripped

    def test_colored_mode_color_changes(self):
        s = RawSession()
        hex_prompt = s.colored_breadcrumb()
        s.toggle_entry_mode()
        assert hex_prompt != s.colored_breadcrumb()            # hex vs binary colored differently


class TestTraceView:
    def test_command_and_response_lines(self):
        out = _plain(render_exchange(bytes([0x30, 0x04]),
                                     bytes([0x00, 0x01, 0x02, 0x03]),
                                     protocol="hf14a", is_tty=False))
        assert "Reader → Tag" in out
        assert "Tag → Reader" in out
        assert "30 04" in out            # command bytes shown

    def test_command_only_when_no_response(self):
        out = _plain(render_exchange(bytes([0x26]), None, protocol="hf14a", is_tty=False))
        assert "Reader → Tag" in out
        assert "Tag → Reader" not in out

    def test_annotation_present_for_known_command(self):
        # 0x30 = 14a READ; the decoder should annotate it (exact text may vary)
        out = _plain(render_exchange(bytes([0x30, 0x04]), None, protocol="hf14a", is_tty=False))
        assert "READ" in out.upper()

    def test_accepts_hex_string_response(self):
        # reader raw() returns `data` as a hex STRING — must not crash on bytes()
        out = _plain(render_exchange(b"\x60", "0004040201000f03", protocol="hf14a", is_tty=False))
        assert "60" in out and "00 04 04" in out


class TestCliDispatch:
    def test_rawcli_subcommand_parsed(self):
        args = build_parser().parse_args(["rawcli", "--port", "/dev/ttyACM0"])
        assert args.command == "rawcli" and args.port == "/dev/ttyACM0"

    def test_no_command_prints_help(self, capsys):
        rc = main([])
        assert rc == 1
        assert "rawcli" in capsys.readouterr().out


class TestParser:
    def test_hex_tokens(self):
        assert parse_token("30") == b"\x30"
        assert parse_token("0x3004") == b"\x30\x04"
        assert parse_bytes("30 04") == b"\x30\x04"
        assert parse_bytes("3004") == b"\x30\x04"       # default hex mode

    def test_binary_tokens(self):
        assert parse_token("0b00110000") == b"\x30"
        assert parse_token("00110000", "bin") == b"\x30"

    def test_intermixed(self):
        assert parse_bytes("0b00110000 0x04") == b"\x30\x04"
        assert parse_bytes("0x30 00000100", "bin") == b"\x30\x04"   # bare token uses mode

    def test_bad_tokens(self):
        with pytest.raises(ValueError):
            parse_token("303")          # odd hex
        with pytest.raises(ValueError):
            parse_token("0b0011")       # not a whole byte

    def test_classify_control(self):
        c = parse_line("identify")
        assert c.kind == "control" and c.name == "identify"
        assert parse_line("help ntag215").kind == "control"

    def test_classify_call(self):
        c = parse_line("READ(4)")
        assert c.kind == "call" and c.name == "READ" and c.args == ["4"]
        c = parse_line("WRITE(4, 0x00112233)")
        assert c.args == ["4", "0x00112233"]
        assert parse_line("GET_DATA()").kind == "call"

    def test_classify_raw(self):
        c = parse_line("30 04")
        assert c.kind == "raw" and c.payload == b"\x30\x04"


class TestByteSpace:
    def test_hex_grouping(self):
        assert byte_space("3004", "hex") == "30 04"
        assert byte_space("300", "hex") == "30 0"
        assert byte_space("30 04", "hex") == "30 04"     # idempotent

    def test_binary_grouping(self):
        assert byte_space("0011000000000100", "bin") == "00110000 00000100"

    def test_prefixed_left_alone(self):
        assert byte_space("0x3004", "hex") == "0x3004"   # explicit prefix not mangled
        assert byte_space("0b0011", "hex") == "0b0011"

    def test_leaves_command_words_alone(self):
        # regression: auto-spacing must not mangle non-hex input (a-f in words used to break it)
        assert byte_space("help transponder", "hex") == "help transponder"
        assert byte_space("identify", "hex") == "identify"
        assert byte_space("close", "hex") == "close"     # c,e are hex digits but l,o,s aren't
        assert byte_space("READ(4)", "hex") == "READ(4)"

    def test_spaces_pure_hex(self):
        assert byte_space("deadbeef", "hex") == "de ad be ef"


class TestDispatch:
    def test_quit_returns_false(self):
        assert dispatch(RawSession(), "quit") is False

    def test_help_prints(self, capsys):
        assert dispatch(RawSession(), "help") is True
        assert "rawcli" in capsys.readouterr().out

    def test_raw_renders_without_device(self, capsys):
        assert dispatch(RawSession(), "30 04") is True
        assert "30 04" in _plain(capsys.readouterr().out)

    def test_bad_hex_reports(self, capsys):
        assert dispatch(RawSession(), "0b0011") is True
        assert "whole number of bytes" in capsys.readouterr().out


NTAG216_VERSION = bytes.fromhex("0004040201001303")


def _mock_device(scan14=None, scan15=None, version=None):
    dev = MagicMock()
    dev.hf.iso14a.scan.return_value = scan14 or {"found": False}
    dev.hf.iso15.scan.return_value = scan15 or {"found": False}
    dev.lf.search.return_value = None
    dev.lf.t55.readbl.return_value = {"status": 0}
    dev.lf.read.return_value = {"status": 0}
    dev.lf.download_samples.return_value = bytes([128] * 2000)   # flat -> no LF tag by default
    dev.hf.iso14a.raw.return_value = {"raw": (version + b"\x99\x88") if version else None}
    return dev


class TestIdentify:
    def test_no_device(self):
        s = RawSession()
        r = identify(s)
        assert r["found"] is False and s.field is None

    def test_14a_sak_only_name(self):
        # SAK != 0 -> named from AN10833 Table 4, no GET_VERSION
        s = RawSession(device=_mock_device(
            scan14={"found": True, "sak": 0x08, "atqa": "0400", "uid": "01020304"}))
        r = identify(s)
        assert r["found"] and s.field == "hf" and s.protocol == "hf14a"
        assert s.transponder == "MIFARE Classic 1K"

    def test_14a_getversion_exact(self):
        s = RawSession(device=_mock_device(
            scan14={"found": True, "sak": 0x00, "atqa": "4400", "uid": "04a1b2c3d4e5f6"},
            version=NTAG216_VERSION))
        r = identify(s)
        assert s.transponder == "NTAG216"          # exact, not "MIFARE UL/NTAG"
        assert r["version"] == NTAG216_VERSION.hex()
        s.device.hf.iso14a.raw.assert_called_with(b"\x60", flags=0x20)   # real GET_VERSION+CRC

    def test_15693_when_e0_uid(self):
        s = RawSession(device=_mock_device(scan15={"found": True, "uid": "e004010203040506"}))
        r = identify(s)
        assert r["found"] and s.field == "hf" and s.protocol == "hf15"
        assert s.transponder == "ISO15693"

    def test_15693_rejects_bogus_uid(self):
        # a flaky 14a miss can leave a non-E0 "uid" — must NOT be reported as a 15693 tag
        s = RawSession(device=_mock_device(scan15={"found": True, "uid": "0000000000003d42"}))
        r = identify(s)
        assert r["found"] is False and s.transponder is None

    def test_no_flat_lf(self):
        # nothing on HF and a flat LF envelope must report not-found, not a bogus "LF tag"
        assert identify(RawSession(device=_mock_device()))["found"] is False

    def test_lf_wiring_sets_label(self, monkeypatch):
        # the LF path folds pm3py.lf.identify_lf's result into the session (demod itself is
        # covered in test_lf_demod.py); here we assert the rawcli wiring/label/summary.
        import pm3py.lf
        monkeypatch.setattr(pm3py.lf, "identify_lf", lambda dev, emit=None: {
            "found": True, "field": "lf", "protocol": "lf", "chip": "T5577",
            "config": "00148040", "emulating": "EM4100 / EM4102",
            "emitted": {"protocol": "EM4100", "id_hex": "0102030405"},
            "label": "T5577 (EM4100 / EM4102)"})
        s = RawSession(device=_mock_device())        # HF finds nothing -> LF path
        r = identify(s)
        assert r["found"] and s.field == "lf" and s.protocol == "lf"
        assert s.transponder == "T5577 (EM4100 / EM4102)"
        assert r["config"] == "00148040" and r["id"] == "0102030405"
        assert "config 0x00148040" in format_summary(r)

    def test_lf_native_credential_label(self, monkeypatch):
        import pm3py.lf
        monkeypatch.setattr(pm3py.lf, "identify_lf", lambda dev, emit=None: {
            "found": True, "field": "lf", "protocol": "lf", "chip": None, "config": None,
            "emulating": None, "emitted": {"protocol": "EM4100", "id_hex": "1122334455"},
            "label": "EM4100 1122334455"})
        s = RawSession(device=_mock_device())
        r = identify(s)
        assert s.transponder == "EM4100 1122334455"
        assert "id 1122334455" in format_summary(r)

    def test_identify_clears_stale_result(self):
        # a second identify that finds nothing must clear the previous tag from the session
        dev = _mock_device(scan14={"found": True, "sak": 0x08, "atqa": "0400", "uid": "b978423d"})
        s = RawSession(device=dev)
        identify(s)
        assert s.transponder == "MIFARE Classic 1K"
        dev.hf.iso14a.scan.return_value = {"found": False}          # tag removed
        identify(s)
        assert s.transponder is None and s.field is None            # no stale data

    def test_sak_names_from_an10833(self):
        assert name_14a({"sak": 0x18}) == "MIFARE Classic 4K"
        assert name_14a({"sak": 0x20}).startswith("ISO14443-4")
        assert name_14a({"sak": 0x99}) == "ISO14443-A (SAK 99)"

    def test_clear_forgets_tag(self):
        s = RawSession(device=_mock_device(scan14={"found": True, "sak": 0x08, "uid": "01020304"}))
        identify(s)
        clear(s)
        assert s.field is None and s.transponder is None and s.protocol == "hf14a"


class TestVersionId:
    def test_exact_models(self):
        from pm3py.cli.rawcli.identify import decode_version
        assert decode_version(bytes.fromhex("0004040201001303")) == "NTAG216"
        assert decode_version(bytes.fromhex("0004040201000f03")) == "NTAG213"
        assert "Ultralight EV1" in decode_version(bytes.fromhex("0004030101000b03"))

    def test_structural_range_for_unknown(self):
        from pm3py.cli.rawcli.identify import decode_version
        # unknown NTAG-family version -> product + honest size range (AN10833)
        out = decode_version(bytes.fromhex("0004040201001503"))
        assert out.startswith("NTAG (") and "B)" in out

    def test_static_map_matches_models(self):
        # guard against drift between the static version map and the transponder models
        from pm3py.cli.rawcli.identify import _VERSION_MODELS
        from pm3py.sim import (NTAG210, NTAG212, NTAG213, NTAG215, NTAG216,
                               MF0UL11, MF0UL21, NT3H2111, NT3H2211)
        model_vbytes = {c._version_bytes.hex() for c in
                        (NTAG210, NTAG212, NTAG213, NTAG215, NTAG216,
                         MF0UL11, MF0UL21, NT3H2111, NT3H2211)}
        assert set(_VERSION_MODELS) == model_vbytes


class TestControlCommands:
    def test_identify_command(self, capsys):
        s = RawSession(device=_mock_device(
            scan14={"found": True, "sak": 0x00, "atqa": "4400", "uid": "04a1b2c3d4e5f6"},
            version=NTAG216_VERSION))
        dispatch(s, "identify")
        out = _plain(capsys.readouterr().out)
        assert "NTAG216" in out                          # exact model in the summary
        assert "WUPA" in out and "GET_VERSION" in out     # probe exchanges streamed to the trace
        assert s.breadcrumb() == "[raw / hf / NTAG216 / 0x]"

    def test_transponder_when_none(self, capsys):
        dispatch(RawSession(), "transponder")
        assert "run 'identify'" in capsys.readouterr().out

    def test_close(self, capsys):
        s = RawSession(device=_mock_device(scan14={"found": True, "sak": 0x08}))
        dispatch(s, "identify")
        dispatch(s, "close")
        assert "closed" in capsys.readouterr().out
        assert s.transponder is None


class TestCatalog:
    def test_type2_builds(self):
        assert TYPE2.get("READ").build("4") == b"\x30\x04"
        assert TYPE2.get("read").build("0x04") == b"\x30\x04"     # case + hex arg
        assert TYPE2.get("FAST_READ").build("0", "3") == b"\x3A\x00\x03"
        assert TYPE2.get("GET_VERSION").build() == b"\x60"
        assert TYPE2.get("WRITE").build("4", "01020304") == b"\xA2\x04\x01\x02\x03\x04"
        assert TYPE2.get("PWD_AUTH").build("FFFFFFFF") == b"\x1B\xFF\xFF\xFF\xFF"
        # two-phase write builds a frame list: command frame + 16-byte data frame
        assert TYPE2.get("COMPAT_WRITE").build("4", "0102") == [b"\xA0\x04", b"\x01\x02" + b"\x00" * 14]

    def test_iso15_builds(self):
        assert ISO15.get("READ_BLOCK").build("4") == b"\x02\x20\x04"
        assert ISO15.get("INVENTORY").build() == b"\x26\x01\x00"

    def test_resolver(self):
        s = RawSession()
        assert catalog_for(s) is None                       # nothing identified
        s.protocol, s.transponder = "hf14a", "NTAG215"
        assert catalog_for(s) is TYPE2
        s.transponder = "MIFARE Classic 1K"
        assert catalog_for(s).name == "MIFARE Classic"
        s.protocol, s.transponder = "hf15", "ISO15693"
        assert catalog_for(s) is ISO15

    def test_resolver_lf(self):
        # identify sets an LF transponder -> the completer/hints get a catalog, not None
        s = RawSession()
        s.protocol, s.transponder = "lf", "T5577 (EM4100 20260716FF)"
        assert catalog_for(s) is T5577                       # command-rich emulator
        s.transponder = "EM4100 20260716FF"                  # a native read-only credential
        assert catalog_for(s) is LF_READONLY

    def test_t5577_opcodes(self):
        # build() exposes the downlink opcode for hex/binary completion (execution is via run)
        assert T5577.get("READ").build("0")[0] == 0x01
        assert T5577.get("WRITE").build("0", "0")[0] == 0x02
        assert T5577.get("WAKE").build("0")[0] == 0x03
        assert {c.name for c in T5577.commands.values()} == {"READ", "WRITE", "WAKE", "DETECT"}
        assert T5577.get("READ").run is not None and LF_READONLY.get("INFO").run is not None


class TestFunctionCalls:
    def _id(self, sak=0x00):
        return RawSession(device=_mock_device(
            scan14={"found": True, "sak": sak, "atqa": "4400", "uid": "04010203"}))

    def test_call_read_sends_correct_bytes(self, capsys):
        s = self._id()
        dispatch(s, "identify")
        s.device.hf.iso14a.raw.return_value = {"raw": b"\xAA\xBB\xCC\xDD"}
        capsys.readouterr()
        dispatch(s, "READ(4)")
        out = _plain(capsys.readouterr().out)
        assert "30 04" in out           # the built command hit the trace
        s.device.hf.iso14a.raw.assert_called_with(b"\x30\x04", flags=0x20)   # CRC appended

    def test_two_phase_write_sends_both_frames(self, capsys):
        s = self._id()                  # SAK 0 -> Type 2 catalog
        dispatch(s, "identify")
        s.device.hf.iso14a.raw.return_value = {"raw": b"\x0A"}   # ACK
        s.device.hf.iso14a.raw.reset_mock()
        dispatch(s, "COMPAT_WRITE(4, 01020304)")
        calls = s.device.hf.iso14a.raw.call_args_list
        assert len(calls) == 2                                   # command frame + data frame
        assert calls[0].args[0] == b"\xA0\x04"
        assert calls[1].args[0] == b"\x01\x02\x03\x04" + b"\x00" * 12

    def test_read_annotates_memory_region(self, capsys):
        # READ output names the datasheet regions the pages cover (the user's ask)
        s = RawSession(device=_mock_device(
            scan14={"found": True, "sak": 0x00, "atqa": "4400", "uid": "04a1b2c3d4e5f6"},
            version=NTAG216_VERSION))
        dispatch(s, "identify")
        assert s.transponder == "NTAG216"
        s.device.hf.iso14a.raw.return_value = {"raw": b"\x03\x00\xFE\x00" * 4}
        capsys.readouterr()
        dispatch(s, "READ(4)")
        assert "04-07 → user memory" in _plain(capsys.readouterr().out)
        dispatch(s, "READ(0)")
        o = _plain(capsys.readouterr().out)
        assert "UID / serial number" in o and "Capability Container" in o

    def test_call_without_identify(self, capsys):
        dispatch(RawSession(), "READ(4)")
        assert "identify" in capsys.readouterr().out

    def test_unknown_call(self, capsys):
        s = self._id(); dispatch(s, "identify"); capsys.readouterr()
        dispatch(s, "FLY(4)")
        assert "unknown command" in capsys.readouterr().out

    def test_bad_args_shows_usage(self, capsys):
        s = self._id(); dispatch(s, "identify"); capsys.readouterr()
        dispatch(s, "READ()")           # missing page arg
        assert "usage: READ(page)" in capsys.readouterr().out

    def test_help_lists_catalog(self, capsys):
        s = self._id(); dispatch(s, "identify"); capsys.readouterr()
        dispatch(s, "help")
        out = capsys.readouterr().out
        assert "READ(page)" in out and "GET_VERSION" in out

    def test_help_command_detail(self, capsys):
        s = self._id(); dispatch(s, "identify"); capsys.readouterr()
        dispatch(s, "help READ")
        assert "0x30" in capsys.readouterr().out


class TestTLV:
    # NULL + NDEF (a well-known text record "Hi"/en) + TERMINATOR
    TEXT_REC = bytes.fromhex("D101055402656E4869")   # D1 01 05 T 02 'en' 'Hi'
    BLOCK = bytes([0x00, 0x03, len(TEXT_REC)]) + TEXT_REC + bytes([0xFE])

    def test_parse_structure(self):
        tlvs = parse_tlv(self.BLOCK)
        tags = [t.tag for t in tlvs]
        assert tags == [0x00, 0x03, 0xFE]
        ndef = tlvs[1]
        assert ndef.length == len(self.TEXT_REC) and ndef.value == self.TEXT_REC

    def test_extended_length(self):
        big = bytes([0x03, 0xFF, 0x01, 0x00]) + b"\x00" * 256 + bytes([0xFE])
        tlvs = parse_tlv(big)
        assert tlvs[0].tag == 0x03 and tlvs[0].length == 256

    def test_format_multiline(self):
        out = format_tlv(self.BLOCK)
        assert "NULL" in out
        assert "NDEF MESSAGE  len=9" in out
        assert "TERMINATOR" in out
        assert "\n" in out                          # genuinely multi-line
        assert "→" in out                            # NDEF annotation line present

    def test_tlv_command(self, capsys):
        dispatch(RawSession(), "tlv " + self.BLOCK.hex())
        assert "NDEF MESSAGE" in capsys.readouterr().out


class TestCompleter:
    def _complete(self, session, text):
        from prompt_toolkit.document import Document
        return list(RawCompleter(session).get_completions(Document(text), None))

    def test_completes_control_verbs(self):
        cs = self._complete(RawSession(), "ide")
        assert any(c.text == "identify" for c in cs)

    def test_completes_catalog_commands_with_meta(self):
        s = RawSession()
        s.protocol, s.transponder = "hf14a", "NTAG215"     # -> Type 2 catalog
        cs = self._complete(s, "REA")
        texts = [c.text for c in cs]
        assert "READ(" in texts
        read = next(c for c in cs if c.text == "READ(")
        assert "0x30" in read.display_meta_text        # tooltip = help

    def test_no_catalog_before_identify(self):
        cs = self._complete(RawSession(), "REA")
        assert all(c.text != "READ(" for c in cs)      # no tag => no catalog commands

    def test_help_argument_completes_command_names(self):
        s = RawSession()
        s.protocol, s.transponder = "hf14a", "NTAG215"
        cs = self._complete(s, "help GET")
        assert any(c.text == "GET_VERSION" for c in cs)

    def test_opcode_completion_hex(self):
        s = RawSession()
        s.protocol, s.transponder = "hf14a", "NTAG213"
        cs = self._complete(s, "60")                # GET_VERSION opcode
        assert any(c.text == "GET_VERSION(" for c in cs)

    def test_opcode_completion_binary(self):
        s = RawSession()
        s.protocol, s.transponder = "hf14a", "NTAG213"
        s.entry_mode = "bin"
        cs = self._complete(s, "01100000")          # 0x60 in binary
        assert any(c.text == "GET_VERSION(" for c in cs)


class TestMemoryHint:
    def _sess(self, tp="NTAG213"):
        s = RawSession()
        s.protocol, s.transponder = "hf14a", tp
        return s

    def test_page_role(self):
        from pm3py.cli.rawcli.memory import page_role
        assert page_role("NTAG213", 0) == "UID / serial number"
        assert page_role("NTAG213", 3) == "Capability Container (CC)"
        assert page_role("NTAG213", 4) == "user memory"
        assert "AUTH0" in page_role("NTAG213", 0x29)      # CFG0
        assert page_role("NTAG213", 0x2A).startswith("CFG1")
        assert "PWD" in page_role("NTAG213", 0x2B)
        assert page_role("NTAG216", 0x04) == "user memory"   # different IC, different pages
        assert "AUTH0" in page_role("NTAG216", 0xE3)

    def test_hint_command_and_page_location(self):
        from pm3py.cli.rawcli.memory import input_hint
        s = self._sess()
        assert "user memory" in input_hint(s, "READ(4)")
        assert "PWD" in input_hint(s, "READ(0x2B")          # partial input + hex arg
        assert "Capability Container" in input_hint(s, "WRITE(3,")

    def test_hint_command_only(self):
        from pm3py.cli.rawcli.memory import input_hint
        s = self._sess()
        assert input_hint(s, "GET_VERSION").startswith("GET_VERSION()")
        assert input_hint(s, "") is None

    def test_hint_needs_transponder(self):
        from pm3py.cli.rawcli.memory import input_hint
        assert input_hint(RawSession(), "READ(4)") is None

    def test_region_annotation(self):
        from pm3py.cli.rawcli.memory import region_annotation
        assert region_annotation("NTAG216", [0, 1, 2, 3]) == \
            "00-02 → UID / serial number  ·  03 → Capability Container (CC)"
        assert region_annotation("NTAG216", [4, 5, 6, 7]) == "04-07 → user memory"
        assert "PWD" in region_annotation("NTAG213", [0x2B])
        assert region_annotation("MIFARE Classic 1K", [4]) is None   # no layout -> no annotation
        assert region_annotation("NTAG216", []) is None

    def test_t5577_block_roles(self):
        from pm3py.cli.rawcli.memory import page_role, input_hint
        tp = "T5577 (EM4100 20260716FF)"
        assert "config" in page_role(tp, 0)
        assert "password" in page_role(tp, 7)
        assert "data" in page_role(tp, 3)
        s = RawSession()
        s.protocol, s.transponder = "lf", tp
        assert "config" in input_hint(s, "READ(0")           # block-role relevance for LF too
        assert "password" in input_hint(s, "WRITE(7,")

    def test_layouts_match_models(self):
        from pm3py.cli.rawcli.memory import _LAYOUTS
        from pm3py.sim import NTAG210, NTAG212, NTAG213, NTAG215, NTAG216
        for cls, name in [(NTAG210, "NTAG210"), (NTAG212, "NTAG212"), (NTAG213, "NTAG213"),
                          (NTAG215, "NTAG215"), (NTAG216, "NTAG216")]:
            L = _LAYOUTS[name]
            assert (L["cfg0"], L["cfg1"], L["pwd"], L["pack"]) == \
                   (cls._cfg0_page, cls._cfg1_page, cls._pwd_page, cls._pack_page)


class TestKeyBindings:
    def test_install_does_not_raise(self):
        # regression: "c-/" is not a valid prompt_toolkit key and used to crash launch
        from prompt_toolkit.key_binding import KeyBindings
        from pm3py.cli.rawcli.entry import install_key_bindings, TOGGLE_KEYS
        kb = KeyBindings()
        install_key_bindings(kb, RawSession())
        assert len(kb.bindings) >= len(TOGGLE_KEYS)