loading: ask how to load an unrecognised file, like IDA does

Last commit let you SAY how to load a blob. This one notices when you should
have. Interactive IDA pops a dialog when no loader matches; we silently loaded
as x86 at 0 and analysed to nothing, so the flag only helped people who already
knew they needed it — which is exactly the people who don't need help.

formats.sniff() recognises the formats IDA definitely handles (ELF, PE, Mach-O,
dex, wasm, ar, COFF, Intel HEX, S-records). Anything else gets
LoadOptionsScreen: a filterable processor list with human labels, a load-address
field, Enter to accept, Esc to load it the way IDA would have anyway.

Deliberate asymmetry: the sniff only claims formats it is sure about. A false
"unknown" costs one dismissible dialog; a false "known" is the silent wrong
answer this exists to kill. Esc is always an escape hatch.

The list offers 20 processors, not IDA's 73 — most of the rest are museum
pieces, and a name typed into the filter that matches nothing is taken literally
so nothing is actually unreachable. Endianness is spelled out (arm vs armb)
because getting it backwards is the most common route to zero functions.

Asked only when nobody has answered yet: not with --processor, not in project
mode (entries carry their own), and not when a database exists — the .i64
already records how the image was loaded.

Textual trap worth recording: the screen stored the file size in self._size,
which is Widget's own backing field for outer_size. Assigning an int to it
crashes layout with "'int' object has no attribute 'region'" from deep inside
_set_dirty, nowhere near the cause. Same family as the _render collision.

The paragraph conversion now lives in exactly one place (formats.load_args);
BinaryRef and launch both call it.

Verified on a real AArch64 blob: dialog appears, filtering to "arm" leaves two
entries, base 0x8000000 accepted -> "-parm -b800000" -> 35 functions at
0x8002440. An ELF never asks, and neither does a blob that already has a .i64.

tests: new tests/test_formats.py (21) and a load_options scenario asserting the
dialog stays out of the way for a recognised binary. 199/0 scenarios, 39/0
project, 30/0 project UI, 36/0 index, 27/0 pool, 21/0 formats.

1 files changed, 93 insertions, 0 deletions

diff --git a/tests/test_formats.py b/tests/test_formats.py
new file mode 100644
index 0000000..f88021c
--- /dev/null
+++ b/tests/test_formats.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""Format sniffing + load-switch construction (pure stdlib, no IDA)."""
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from idatui.formats import (PROCESSORS, load_args,  # noqa: E402
+                            needs_load_options, sniff)
+
+PASS = FAIL = 0
+
+
+def check(name, ok, detail=""):
+    global PASS, FAIL
+    if ok:
+        PASS += 1
+        print(f"  ok   {name}")
+    else:
+        FAIL += 1
+        print(f"  FAIL {name}   {detail}")
+
+
+def main() -> int:
+    with tempfile.TemporaryDirectory() as tmp:
+        def w(name, data):
+            p = os.path.join(tmp, name)
+            with open(p, "wb") as f:
+                f.write(data)
+            return p
+
+        # -- formats IDA can load on its own: never interrupt the user -------- #
+        for name, head in (("elf", b"\x7fELF\x02\x01\x01"), ("pe", b"MZ\x90\x00"),
+                           ("macho", b"\xcf\xfa\xed\xfe"), ("dex", b"dex\n035\x00"),
+                           ("wasm", b"\x00asm\x01\x00")):
+            p = w(name, head + bytes(60))
+            check(f"{name} is recognised (no dialog)",
+                  sniff(p) is not None and not needs_load_options(p), f"{sniff(p)}")
+
+        # -- the case this exists for ----------------------------------------- #
+        blob = w("fw.bin", bytes(range(256)) * 4)
+        check("a headerless blob is not recognised (ask)",
+              sniff(blob) is None and needs_load_options(blob))
+
+        # Intel HEX / S-records are text containers IDA does load.
+        hexf = w("f.hex", b":10010000214601360121470136007EFE09D2190140\n")
+        check("Intel HEX is recognised", sniff(hexf) == "Intel HEX", f"{sniff(hexf)}")
+        srec = w("f.s19", b"S00600004844521B\nS1130000285F245F2212226A000424290008237C\n")
+        check("Motorola S-records are recognised",
+              sniff(srec) == "Motorola S-record", f"{sniff(srec)}")
+
+        # A binary that merely STARTS with ':' is not Intel HEX. Text formats are
+        # only accepted when the whole head is printable, or half the firmware in
+        # the world gets mis-detected on one byte.
+        colon = w("colon.bin", b":\x00\xff\xfe\x01\x02" + bytes(58))
+        check("a blob starting with ':' is not mistaken for Intel HEX",
+              sniff(colon) is None, f"{sniff(colon)}")
+
+        check("an empty file is not recognised", sniff(w("empty", b"")) is None)
+        check("a missing file never asks (nothing to load)",
+              not needs_load_options(os.path.join(tmp, "nope")))
+        check("a directory never asks", not needs_load_options(tmp))
+
+    # -- switch construction ------------------------------------------------- #
+    # -b is in PARAGRAPHS: 0x8000000 >> 4 == 0x800000. Getting this wrong loads
+    # the image 16x off and every address in the database is wrong.
+    check("base is converted to paragraphs",
+          load_args("arm", 0x8000000) == "-parm -b800000",
+          load_args("arm", 0x8000000))
+    check("processor alone", load_args("mipsb") == "-pmipsb", load_args("mipsb"))
+    check("base alone", load_args("", 0x10000) == "-b1000", load_args("", 0x10000))
+    check("base 0 emits no switch (it's the default)",
+          load_args("arm", 0) == "-parm", load_args("arm", 0))
+    check("nothing in, nothing out", load_args() == "")
+    check("extra switches pass through",
+          load_args("arm", 0, "-T binary") == "-parm -T binary")
+
+    check("the processor list leads with the common targets",
+          [n for n, _ in PROCESSORS[:3]] == ["arm", "armb", "metapc"],
+          f"{[n for n, _ in PROCESSORS[:3]]}")
+    check("every processor entry has a human label",
+          all(n and d for n, d in PROCESSORS))
+    check("endianness is spelled out where it matters",
+          all(any(w in d.lower() for w in ("endian",))
+              for n, d in PROCESSORS if n in ("arm", "armb", "mipsb", "mipsl")))
+
+    print(f"\n{PASS} passed, {FAIL} failed")
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())