diff options
| -rw-r--r-- | tests/test_tui.py | 1236 |
1 files changed, 0 insertions, 1236 deletions
diff --git a/tests/test_tui.py b/tests/test_tui.py deleted file mode 100644 index 6d77fc2..0000000 --- a/tests/test_tui.py +++ /dev/null @@ -1,1236 +0,0 @@ -#!/usr/bin/env python3 -"""Headless pilot test for the Phase-1 TUI (no real terminal needed). - - python3 tests/test_tui.py --db <session_id> - python3 tests/test_tui.py --db <session_id> --stop-after "search finds" - -Drives the app via Textual's Pilot: boots, loads the function list, opens a -function into the virtualized disasm view, scrolls it, and checks the cursor / -status update. Uses ~/ida-venv python (has textual). - ---stop-after <substr> ends the run once a check whose name contains <substr> has -been evaluated, skipping the (often expensive) tail -- handy for fast iteration -on a single feature. The default (no flag) runs the whole suite. -""" -import asyncio -import os -import re -import sys - -sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) -from idatui.app import ( # noqa: E402 - ConfirmScreen, DecompView, DisasmView, FunctionsPanel, HexView, IdaTui, - StructEditor, SymbolPalette, XrefsScreen, -) -from textual.widgets import DataTable, Input, OptionList, Static, TextArea # noqa: E402 -from rich.text import Text # noqa: E402 - -PASS = FAIL = 0 -STOP_AFTER = None # --stop-after <substr>: end the run once a matching check ran - - -class _StopSuite(Exception): - """Unwind cleanly once the requested --stop-after check has been evaluated.""" - - -def check(name, cond, detail=""): - global PASS, FAIL - if cond: - PASS += 1 - print(f" ok {name}") - else: - FAIL += 1 - print(f" FAIL {name} {detail}") - if STOP_AFTER and STOP_AFTER in name: - raise _StopSuite - - -async def wait_until(pilot, pred, timeout=30.0, step=0.02): - # Poll finely so a condition that resolves quickly (the common case on a warm - # session) is detected promptly instead of up to `step` late across the ~50 - # call sites; the timeout ceiling is unchanged. - waited = 0.0 - while waited < timeout: - if pred(): - return True - await pilot.pause(step) - waited += step - return False - - -async def run(db): - url = os.environ.get("IDA_MCP_URL", "http://127.0.0.1:8745/mcp") - app = IdaTui(url=url, db=db, keepalive=False) - async with app.run_test(size=(120, 40)) as pilot: - table = app.query_one("#func-table", DataTable) - status = app.query_one("#status", Static) - - loaded = await wait_until(pilot, lambda: table.row_count > 0) - check("function list populated", loaded, f"rows={table.row_count}") - # The names pane is an overlay now (Ctrl+N) and starts hidden; reveal the - # classic docked pane (Ctrl+B) for the table-driven checks below. - left = app.query_one("#left") - check("names pane starts hidden (overlay-first)", not left.display, - f"display={left.display}") - await pilot.press("ctrl+b") - await wait_until(pilot, lambda: left.display, timeout=5) - check("function pane width is capped (doesn't eat the screen)", - left.size.width <= 44, f"width={left.size.width}") - - got_all = await wait_until( - pilot, lambda: "functions" in str(status.render()) and "…" not in str(status.render()), - timeout=30, - ) - check("function load completed (status settled)", got_all, str(status.render())) - nfuncs = table.row_count - print(f" loaded {nfuncs} functions") - - # Symbol palette (Ctrl+N): fuzzy find + open, overlay-style. - await pilot.press("ctrl+n") - pal_open = await wait_until(pilot, lambda: isinstance(app.screen, SymbolPalette), 10) - check("Ctrl+N opens the symbol palette", pal_open, - f"screen={type(app.screen).__name__}") - if pal_open: - pal = app.screen - pinp = pal.query_one(Input) - pinp.value = "main" - await wait_until(pilot, lambda: pal._results and pal._results[0].name == "main", 10) - check("palette fuzzy-finds (top result matches the query)", - bool(pal._results) and pal._results[0].name == "main", - f"top={pal._results[0].name if pal._results else None}") - pinp.value = "eror" # scattered subsequence of 'error' - await wait_until(pilot, lambda: any(f.name == "error" for f in pal._results), 10) - check("palette matches a fuzzy subsequence", - any(f.name == "error" for f in pal._results), - f"results={[f.name for f in pal._results[:4]]}") - pinp.value = "main" - await wait_until(pilot, lambda: pal._results and pal._results[0].name == "main", 10) - want = pal._results[0].addr - await pilot.press("enter") - await wait_until(pilot, lambda: not isinstance(app.screen, SymbolPalette), 10) - await wait_until(pilot, lambda: app._cur and app._cur.ea == want, 20) - check("selecting a palette entry opens that function", - bool(app._cur) and app._cur.ea == want, - f"cur={app._cur.ea if app._cur else None}") - await pilot.press("ctrl+n") - await wait_until(pilot, lambda: isinstance(app.screen, SymbolPalette), 10) - await pilot.press("escape") - await wait_until(pilot, lambda: not isinstance(app.screen, SymbolPalette), 10) - check("Esc closes the palette", not isinstance(app.screen, SymbolPalette)) - - # Decompile-failure fallback: a function that can't be decompiled opens - # in disassembly (not an error panel), and the pseudocode preference is - # kept so the next decompilable function still opens as pseudocode. - # (Import/PLT stubs at high addresses fail fast; scan from the top.) - d_view = app.query_one(DisasmView) - c_view = app.query_one(DecompView) - failing = next((f for f in reversed(app.program.functions().all_loaded()) - if app.program.decompile(f.addr).failed), None) - if failing is not None and app._pref == "decomp": - app._goto(hex(failing.addr)) - await wait_until(pilot, lambda: app._cur and app._cur.ea == failing.addr, 20) - await wait_until(pilot, lambda: app._active == "disasm", 20) - check("decompile failure falls back to disassembly (preference kept)", - app._active == "disasm" and d_view.display and not c_view.display - and app._pref == "decomp", - f"active={app._active} pref={app._pref} " - f"disp(dis={d_view.display},dec={c_view.display})") - app._goto("main") - await wait_until(pilot, lambda: app._cur and app._cur.name == "main", 20) - await wait_until(pilot, lambda: app._active == "decomp" and c_view.display, 25) - check("preference preserved: next function opens as pseudocode", - app._active == "decomp" and c_view.display, f"active={app._active}") - else: - check("found a decompile-failing function", failing is not None, - f"pref={app._pref}") - - # Struct editor (Ctrl+T): list / view / create / update / delete. - await pilot.press("ctrl+t") - se_open = await wait_until(pilot, lambda: isinstance(app.screen, StructEditor), 10) - check("Ctrl+T opens the struct editor", se_open, - f"screen={type(app.screen).__name__}") - if se_open: - se = app.screen - await wait_until(pilot, lambda: bool(se._structs), 15) - check("struct editor lists existing structs", len(se._structs) > 0, - f"n={len(se._structs)}") - ta = se.query_one(TextArea) - tname = next((s.name for s in se._structs if s.name == "timespec"), - se._structs[0].name) - idx = next(i for i, s in enumerate(se._structs) if s.name == tname) - se.query_one(OptionList).highlighted = idx - se.on_option_list_option_selected(type("E", (), {"option_index": idx})()) - await wait_until(pilot, lambda: tname in ta.text and "{" in ta.text, 15) - check("selecting a struct shows its C definition", - tname in ta.text and "{" in ta.text, f"text={ta.text[:40]!r}") - # Ctrl+Y copies the whole definition to the clipboard (OSC 52 + tmux). - app._clipboard = "" - se.query_one(TextArea).focus() - await pilot.press("ctrl+y") - await wait_until(pilot, lambda: app._clipboard == ta.text, 10) - check("Ctrl+Y copies the struct definition to the clipboard", - bool(app._clipboard) and app._clipboard == ta.text, - f"clip_len={len(app._clipboard)}") - # create (fixed name so re-runs update in place -> no churn) - sname = "TuiEdTest" - await pilot.press("ctrl+n") - await pilot.pause(0.05) - ta.text = f"struct {sname} {{ int a; char b[8]; }};" - await pilot.press("ctrl+s") - await wait_until(pilot, lambda: any(s.name == sname for s in se._structs), 15) - check("Ctrl+S declares a new struct", - any(s.name == sname for s in se._structs), "not created") - # save auto-formats the (one-line) definition to canonical layout - await wait_until(pilot, lambda: "\n" in ta.text, 10) - check("save auto-formats the definition in the editor", - ta.text.count("\n") >= 3 and f"struct {sname}" in ta.text - and not se._is_dirty(), f"text={ta.text[:50]!r}") - # update it (add a field -> member count grows) - idx = next(i for i, s in enumerate(se._structs) if s.name == sname) - se.on_option_list_option_selected(type("E", (), {"option_index": idx})()) - await wait_until(pilot, lambda: sname in ta.text, 10) - ta.text = f"struct {sname} {{ int a; char b[8]; long c; }};" - await pilot.press("ctrl+s") - await wait_until( - pilot, - lambda: next((s.members for s in se._structs if s.name == sname), 0) == 3, - 15) - check("Ctrl+S updates an existing struct in place", - next((s.members for s in se._structs if s.name == sname), 0) == 3, - "member count not 3") - # A save IDA's C parser rejects (the reserved field name '__unused') - # fails loudly and non-destructively, naming the offending field. - ta.text = f"struct {sname} {{ int a; char b[8]; long c; int __unused; }};" - await pilot.press("ctrl+s") - await wait_until( - pilot, lambda: "save failed" in str(se.query_one("#se-status").render()), 15) - st = str(se.query_one("#se-status").render()) - check("a rejected save fails loudly, naming the reserved field", - "save failed" in st and "__unused" in st, f"status={st!r}") - check("a rejected save leaves the struct unchanged", - next((s.members for s in se._structs if s.name == sname), 0) == 3, - "members changed") - check("a rejected save keeps your edited text", "__unused" in ta.text) - # Unsaved edits are guarded when switching structs. - other = next(i for i, s in enumerate(se._structs) if s.name != sname) - se.on_option_list_option_selected(type("E", (), {"option_index": other})()) - guard = await wait_until(pilot, lambda: isinstance(app.screen, ConfirmScreen), 10) - check("unsaved edits prompt before switching structs", guard, - f"screen={type(app.screen).__name__}") - await pilot.press("enter") # confirm discard -> loads the other (clean) - await wait_until( - pilot, lambda: isinstance(app.screen, StructEditor) and not se._is_dirty(), 15) - # delete: 'd' asks to confirm, Enter deletes (server del_type). If the - # server lacks del_type, the status reports it instead. - idx = next(i for i, s in enumerate(se._structs) if s.name == sname) - se.query_one(OptionList).focus() - se.query_one(OptionList).highlighted = idx - await pilot.press("d") - confirmed = await wait_until( - pilot, lambda: isinstance(app.screen, ConfirmScreen), 10) - check("delete asks for confirmation", confirmed, - f"screen={type(app.screen).__name__}") - await pilot.press("enter") - await wait_until(pilot, lambda: isinstance(app.screen, StructEditor), 10) - await wait_until( - pilot, - lambda: not any(s.name == sname for s in se._structs) - or "del_type" in str(se.query_one("#se-status").render()), 15) - st = str(se.query_one("#se-status").render()) - gone = not any(s.name == sname for s in se._structs) - check("confirming delete removes the struct (or reports missing tool)", - gone or "del_type" in st, f"gone={gone} status={st!r}") - se.query_one(OptionList).focus() - await pilot.press("escape") - await wait_until(pilot, lambda: not isinstance(app.screen, StructEditor), 10) - check("Esc closes the struct editor", not isinstance(app.screen, StructEditor)) - - # Open the biggest function we can find (scan a sample of rows for size). - # Simpler: select the row whose Size column is largest among first N. - biggest_i, biggest_sz = 0, -1 - scan = min(nfuncs, 4000) - for i in range(scan): - row = table.get_row_at(i) - sz = int(str(row[2]), 16) - if sz > biggest_sz: - biggest_sz, biggest_i = sz, i - - table.move_cursor(row=biggest_i) - await pilot.pause(0.05) - table.focus() - await pilot.press("enter") - - view = app.query_one(DisasmView) - opened = await wait_until(pilot, lambda: view.total > 0, timeout=30) - check("disasm view opened with a total", opened, f"total={view.total}") - print(f" opened func with {view.total} instructions") - - # Pseudocode is the DEFAULT view: the first function opens into it. - dec0 = app.query_one(DecompView) - pc = await wait_until( - pilot, lambda: app._active == "decomp" and dec0.display - and dec0.loaded_ea is not None, 25) - check("opening a function shows pseudocode by default", pc, - f"active={app._active} disp={dec0.display}") - # Switch to disassembly for the disasm scrolling checks below. - await pilot.press("tab") - await wait_until(pilot, lambda: app._active == "disasm", 10) - view.focus() - - # Wait for the first lines to be cached, then verify a rendered line. - cached = await wait_until( - pilot, lambda: view.model is not None and view.model.cached_line(0) is not None, - timeout=20, - ) - check("first instruction cached", cached) - - # Scroll down a page and confirm cursor advances + status shows an ea. - for _ in range(5): - await pilot.press("pagedown") - await pilot.pause(0.025) - moved = view.cursor > 0 - check("pagedown moved the cursor", moved, f"cursor={view.cursor}") - await wait_until(pilot, lambda: view.model.cached_line(view.cursor) is not None, 15) - check("cursor line eventually cached (bg fetch)", - view.model.cached_line(view.cursor) is not None) - check("status shows an address", "@ 0x" in str(status.render()), str(status.render())) - - # Ctrl+Y copies the current code line to the clipboard. - view.focus() - cur_line = view._line_plain(view.cursor) - app._clipboard = "" - await pilot.press("ctrl+y") - await wait_until(pilot, lambda: app._clipboard == cur_line, 10) - check("Ctrl+Y copies the current code line to the clipboard", - bool(cur_line) and app._clipboard == cur_line, f"clip={app._clipboard!r}") - - # Jump to bottom of a (possibly huge) function; must not hang. - await pilot.press("end") - await pilot.pause(0.05) - check("goto-bottom lands near end", - view.cursor >= view.total - 1, f"cursor={view.cursor}/{view.total}") - - # Hex view: backslash shows the raw image bytes synced to the code cursor. - view.focus() - code_ea = view._cursor_ea() - await pilot.press("backslash") - await wait_until(pilot, lambda: app._active == "hex", 10) - hx = app.query_one(HexView) - await wait_until( - pilot, lambda: hx.model is not None - and hx.model.row(hx.cursor // 16)[1] is not None, 20) - check("backslash opens the hex view synced to the code cursor", - app._active == "hex" and code_ea is not None and hx.cursor_va() == code_ea, - f"active={app._active} hexva={hx.cursor_va():#x} ea={code_ea}") - want = app.program.read_bytes(code_ea, 1) - _, rb = hx.model.row(hx.cursor // 16) - check("hex shows the actual byte at that address", - rb is not None and rb[hx.cursor % 16] == want[0], - f"got={rb[hx.cursor % 16] if rb else None} want={want[0]}") - await pilot.press("l") - await pilot.pause(0.1) - check("hex cursor steps one byte", hx.cursor_va() == code_ea + 1, - f"va={hx.cursor_va():#x}") - await pilot.press("backslash") # back to the code view - await wait_until(pilot, lambda: app._active != "hex", 10) - check("backslash returns from hex to the code view", - app._active == "disasm", f"active={app._active}") - - # Filter round-trip. '/' is context-sensitive: it filters when the - # function table is focused (and searches when a code view is focused), - # so focus the table first. - table.focus() - await pilot.pause(0.05) - await pilot.press("slash") - await pilot.pause(0.05) - for ch in "sub_1*": - await pilot.press(ch if ch != "*" else "asterisk") - await pilot.press("enter") - filtered = await wait_until( - pilot, lambda: table.row_count > 0 and table.row_count < nfuncs, timeout=15 - ) - check("filter narrowed the list", filtered, f"rows={table.row_count} of {nfuncs}") - - # Toggle the functions pane show/hide. - left = app.query_one("#left", FunctionsPanel) - await pilot.press("ctrl+b") - await pilot.pause(0.05) - check("ctrl+b hides functions pane + focuses disasm", - not left.display and isinstance(app.focused, DisasmView), - f"display={left.display} focus={type(app.focused).__name__}") - await pilot.press("ctrl+b") - await pilot.pause(0.05) - check("ctrl+b again restores pane + focuses table", - left.display and isinstance(app.focused, DataTable), - f"display={left.display} focus={type(app.focused).__name__}") - - # The 'sub_1*' round-trip above left the list filtered; clear it so the - # full table is back and biggest_i (an unfiltered row index) is valid. - app.clear_filter() - await wait_until(pilot, lambda: table.row_count == nfuncs, timeout=15) - - # Tab toggles between pseudocode and disassembly (view state persists - # across opens, so normalize to pseudocode first). - table.focus() - table.move_cursor(row=biggest_i) - await pilot.press("enter") - dis = app.query_one(DisasmView) - dec = app.query_one(DecompView) - await wait_until(pilot, lambda: dis.total > 0, timeout=20) - if app._active != "decomp": - await pilot.press("tab") - pc = await wait_until( - pilot, lambda: dec.display and dec.loaded_ea is not None - and app._active == "decomp", 25) - check("tab shows pseudocode", pc, f"active={app._active} disp={dec.display}") - check("pseudocode has many lines", dec.total > 20, f"lines={dec.total}") - # Highlighting: at least one styled (colored) segment across the body. - styled = any( - seg.style is not None and seg.style.color is not None - for strip in dec._strips[: min(dec.total, 200)] - for seg in strip - ) - check("pseudocode is syntax-highlighted", styled) - await pilot.press("tab") - await pilot.pause(0.1) - check("tab switches to disassembly", - app._active == "disasm" and dis.display and not dec.display, - f"active={app._active}") - await pilot.press("tab") # back to pseudocode for the overlay/gutter checks - await wait_until(pilot, lambda: app._active == "decomp", 10) - - # A (re)decompile shows a grayed 'decompiling…' overlay while it runs. - if app._active != "decomp": - await pilot.press("tab") - await wait_until(pilot, lambda: app._active == "decomp", timeout=10) - await wait_until(pilot, lambda: dec.loaded_ea is not None, timeout=20) - dec.loaded_ea = None # force a reload (as rename/refresh does) - app._show_active() - cover = dec._cover_widget - check("decompile shows a 'decompiling…' overlay", - dec.loading and cover is not None - and "decomp-loading" in cover.classes - and "decompiling" in str(cover.render()), - f"loading={dec.loading} cover={cover!r}") - await wait_until(pilot, lambda: not dec.loading and dec._cover_widget is None, - timeout=25) - check("overlay clears when the decompile finishes", - not dec.loading and dec._cover_widget is None) - # Line-number gutter. - dec.scroll_to(0, 0, animate=False) - await pilot.pause(0.025) - row0 = "".join(seg.text for seg in dec.render_line(0)) - check("pseudocode has a numbered gutter (line 1 first)", - dec._gutter > 0 and row0[:dec._gutter].strip() == "1", - f"gutter={dec._gutter} row0={row0[:10]!r}") - await pilot.press("tab") # back to disasm for the rest of the tests - await wait_until(pilot, lambda: app._active == "disasm", timeout=10) - - # Vim-style search in the disassembly view. - line0 = dis.model.cached_line(0) - raw = (line0.text.split() or ["push"])[0] if line0 else "push" - term = "".join(c for c in raw if c.isalnum())[:4] or "push" - await pilot.press("slash") - await pilot.pause(0.1) - for ch in term: - await pilot.press(ch) - await pilot.press("enter") - await wait_until(pilot, lambda: bool(dis._matches), timeout=25) - check("search finds matches", len(dis._matches) > 0, f"term={term!r}") - check("cursor sits on a match", dis.cursor in dis._matches, f"cursor={dis.cursor}") - check("match substring highlighted", - bool(dis._ranges.get(dis.cursor)), str(dis._ranges.get(dis.cursor))) - check("search cursor lands on the match's starting column", - dis.cursor_x == dis._ranges[dis.cursor][0][0], - f"cursor_x={dis.cursor_x} ranges={dis._ranges.get(dis.cursor)}") - prev = dis.cursor - await pilot.press("slash") - await pilot.pause(0.05) - await pilot.press("enter") - await pilot.pause(0.05) - check("'/' repeats to next match", - dis.cursor != prev and dis.cursor in dis._matches, f"cursor={dis.cursor}") - await pilot.press("question_mark") - await pilot.pause(0.05) - await pilot.press("enter") - await pilot.pause(0.05) - check("'?' repeats to previous match", dis.cursor in dis._matches, - f"cursor={dis.cursor}") - - # Incremental search + visible bar + Esc cancel. - si = app.query_one("#search", Input) - status = app.query_one("#status", Static) - await pilot.press("slash") - await pilot.pause(0.1) - check("search bar visible, status hidden (no overlap)", - si.display and not status.display, f"si={si.display} status={status.display}") - from textual.widgets import Footer as _Footer - footer = app.query_one(_Footer) - check("search input is rendered above the footer (not overlapping)", - si.region.height >= 1 and si.region.y < footer.region.y, - f"search={si.region} footer={footer.region}") - for ch in term: - await pilot.press(ch) - await pilot.pause(0.05) - check("matches highlight incrementally (before Enter)", - len(dis._matches) > 0 and si.value == term, f"val={si.value!r}") - await pilot.press("escape") - await pilot.pause(0.1) - check("Esc cancels: status restored, matches cleared", - status.display and not si.display and not dis._matches, - f"status={status.display} si={si.display} m={len(dis._matches)}") - - # Incremental function-name filter + highlight + Esc-clear. - table.focus() - await pilot.pause(0.05) - if app._filter_term: # clear any leftover filter from earlier - await pilot.press("escape") - await pilot.pause(0.1) - full = table.row_count - await pilot.press("slash") - await pilot.pause(0.1) - for ch in "sub_": - await pilot.press(ch) - await pilot.pause(0.05) - await pilot.pause(0.1) - check("filter narrows incrementally as you type", - 0 < table.row_count < full, f"{table.row_count}/{full}") - cell = table.get_row_at(0)[1] - check("filter highlights matched substring in name", - isinstance(cell, Text) and any(s.style for s in cell.spans), repr(str(cell))) - await pilot.press("enter") - await pilot.pause(0.1) - check("Enter keeps filter + focuses table", - isinstance(app.focused, DataTable) and table.row_count < full) - await pilot.press("escape") - await pilot.pause(0.15) - check("Esc on the list clears the filter", table.row_count == full, - f"{table.row_count}/{full}") - - # Follow (Enter) + back (Esc) + xrefs (x), using a real call site. - dis = app.query_one(DisasmView) - dis.focus() - await pilot.pause(0.05) - lines = dis.model.lines(0, 400, prefetch=False) - call_idx = next((i for i, ln in enumerate(lines) - if ln.text.startswith("call ")), None) - if call_idx is None: - check("found a call line to exercise follow/xrefs", False, "no call in first 400") - else: - dis.cursor = call_idx - dis.refresh() - orig = app._cur.ea - orig_name = app._cur.name - depth = len(app._nav) - await pilot.press("enter") - await wait_until(pilot, lambda: len(app._nav) > depth, timeout=25) - check("Enter follows the call into another function", - app._cur.ea != orig and len(app._nav) > depth, f"cur={app._cur.ea:#x}") - await pilot.press("escape") - await pilot.pause(0.1) - check("Esc returns from the follow", app._cur.ea == orig, f"cur={app._cur.ea:#x}") - dis.cursor = call_idx - dis.refresh() - await pilot.press("x") - opened = await wait_until( - pilot, lambda: isinstance(app.screen, XrefsScreen), timeout=25) - check("'x' opens the xrefs popup", opened, - f"screen={type(app.screen).__name__}") - if opened: - check("xrefs popup has entries", - app.screen.query_one(OptionList).option_count >= 1) - await pilot.press("escape") - await pilot.pause(0.1) - check("Esc closes the xrefs popup", - not isinstance(app.screen, XrefsScreen)) - - # Selecting an xref must land on the referencing SITE (right function - # AND line), not the function under the cursor. - xf = None - for cand in app.program.functions().all_loaded()[:600]: - codex = [x for x in app.program.xrefs_to(cand.addr) - if x.type == "code" and x.frm] - if codex: - xf = (cand, codex[0]) - break - if xf is None: - check("found a function with a code xref", False) - else: - xfn, xref = xf - xexp = app.program.disasm(xref.fn_addr).index_of_ea(xref.frm) - await pilot.press("g") - await pilot.pause(0.1) - for ch in xfn.name: - await pilot.press(ch) - await pilot.press("enter") - await wait_until(pilot, lambda: dis.total > 0 and app._cur.ea == xfn.addr, - timeout=20) - dis.focus() - dis.cursor, dis.cursor_x = 0, 0 # on the entry (address column) - await pilot.press("x") - await wait_until(pilot, lambda: isinstance(app.screen, XrefsScreen), 25) - app.screen.query_one(OptionList).highlighted = 0 - await pilot.press("enter") - await wait_until(pilot, lambda: not isinstance(app.screen, XrefsScreen), 25) - await wait_until(pilot, lambda: app._cur.ea == xref.fn_addr, timeout=25) - await pilot.pause(0.15) - check("xref-select lands on the referencing function + line", - app._cur.ea == xref.fn_addr and dis.cursor == xexp, - f"cur={app._cur.ea:#x} (want {xref.fn_addr:#x}) " - f"cursor={dis.cursor} (want {xexp})") - - # Same jump, but with the DECOMPILER pane active: it must land on - # the reference LINE in pseudocode, not the top of the function. - # (Repro of the reported bug; _on_xref_chosen is the dialog's - # selection callback, the exact seam that was broken.) - dec = app.query_one(DecompView) - dcode = app.program.decompile(xref.fn_addr) - dexp, be = -1, -1 # expected pseudocode line for the ref site - if not dcode.failed and dcode.code: - for i, ln in enumerate(dcode.code.splitlines()): - for mm in re.findall(r"/\*\s*0x([0-9A-Fa-f]+)\s*\*/", ln): - e = int(mm, 16) - if be < e <= xref.frm: - be, dexp = e, i - if dexp >= 0: - app._pref = "decomp" # navigation honours the preferred view - app._open_function(xfn.addr, xfn.name) # start elsewhere - await wait_until(pilot, lambda: app._cur.ea == xfn.addr - and app._active == "decomp", 20) - await wait_until(pilot, lambda: dec.loaded_ea == xfn.addr, 25) - # xfn is the referenced function; its name is the token that - # appears at the call site the xref points to. - app._xref_focus_name = xfn.name - app._on_xref_chosen(xref.frm) # pick the caller from the dialog - await wait_until(pilot, lambda: dec.loaded_ea == xref.fn_addr, 25) - await pilot.pause(0.1) - check("xref-select lands on the reference LINE in pseudocode", - dec.cursor == dexp, f"dec.cursor={dec.cursor} want={dexp}") - # Cursor lands on the reference token's column (or the line - # start if that token isn't literally on the line, e.g. a - # stale Hex-Rays cache renders a different name). - landed = dec._texts[dec.cursor] if dec.cursor < len(dec._texts) else "" - tokm = re.search(rf"\b{re.escape(xfn.name)}\b", landed) - want_col = tokm.start() if tokm else 0 - check("xref-select lands the column on the reference token", - dec.cursor_x == want_col, - f"cursor_x={dec.cursor_x} want={want_col} " - f"token={xfn.name!r} line={landed.strip()!r}") - - # And a jump whose target is INSIDE the already-displayed - # function must still move the cursor (the decompiler pane - # isn't reloaded in that case, so it needs explicit repos). - anch = [(i, dec._line_ea(i)) for i in range(len(dec._texts)) - if dec._line_ea(i) is not None] - if len(anch) >= 4: - start_ln = anch[1][0] - far_ea = anch[len(anch) // 2][1] - exp2 = app._decomp_line_for(app._cur.ea, far_ea) - dec.focus() - dec.cursor = start_ln - dec.refresh() - await pilot.pause(0.05) - app._on_xref_chosen(far_ea) # target within this function - await wait_until(pilot, lambda: dec.cursor == exp2, timeout=20) - check("xref-select moves the cursor within the same function", - dec.cursor == exp2 and exp2 != start_ln, - f"dec.cursor={dec.cursor} want={exp2} start={start_ln}") - app._pref = "disasm" # restore for the following blocks - app._active = "disasm" - app._show_active() - await pilot.pause(0.05) - - # The xref-select sub-test above navigated 'dis' to another function; - # return to the original and materialize the call line so the column - # cursor operates on a cached (non-empty) line. - app._open_function(orig, orig_name) - await wait_until(pilot, lambda: dis.total > 0 and app._cur.ea == orig, 20) - dis.model.lines(0, 400, prefetch=False) - # Column cursor: h/l move it; following the symbol under the cursor. - dis.focus() - dis.cursor = call_idx - dis.cursor_x = 5 - dis.refresh() - await pilot.pause(0.025) - await pilot.press("h") - check("h moves the column cursor left", dis.cursor_x == 4, f"x={dis.cursor_x}") - await pilot.press("l") - await pilot.press("l") - check("l moves the column cursor right", dis.cursor_x == 6, f"x={dis.cursor_x}") - plain = dis._line_plain(call_idx) or "" - m = re.search(r"\b(sub_[0-9A-Fa-f]+)", plain) - if m: - dis.cursor = call_idx - dis.cursor_x = m.start(1) + 1 - dis.refresh() - await pilot.pause(0.05) - check("word-under-cursor is the operand symbol", - dis.word_under_cursor() == m.group(1), - f"{dis.word_under_cursor()!r} vs {m.group(1)!r}") - depth = len(app._nav) - want = app.program.resolve(m.group(1)) - await pilot.press("enter") - await wait_until(pilot, lambda: len(app._nav) > depth, timeout=25) - check("follows the symbol under the cursor", - app._cur.ea == want, f"cur={app._cur.ea:#x} want={want:#x}") - - # Xref labels: function + offset (so several sites in one function are - # distinguishable) and a section name instead of a bare '?' for a - # reference that isn't inside a function. - from collections import Counter, defaultdict - multi = None - for cand in app.program.functions().all_loaded()[:200]: - callers = Counter(x.fn_addr for x in app.program.xrefs_to(cand.addr) - if x.fn_name) - if any(n >= 2 for n in callers.values()): - multi = cand - break - if multi is not None: - table.focus() - await pilot.press("g") - await pilot.pause(0.1) - for ch in multi.name: - await pilot.press(ch) - await pilot.press("enter") - await wait_until(pilot, lambda: app._cur and app._cur.ea == multi.addr, 20) - if app._active != "disasm": - await pilot.press("tab") - dis.focus() - dis.cursor, dis.cursor_x = 0, 0 - dis.refresh() - await pilot.press("x") - await wait_until(pilot, lambda: isinstance(app.screen, XrefsScreen), 25) - labels = [t for _, t in app.screen._items] - # location column = the text between the leading addr and the [type] - locs = [l.split("[")[0].split(None, 1)[1].strip() for l in labels] - byfn = defaultdict(set) - for x in locs: - if "+0x" in x: - nm, off = x.split("+0x", 1) - byfn[nm].add(off) - check("xref labels distinguish multiple sites in a function by offset", - any(len(offs) >= 2 for offs in byfn.values()), f"locs={locs[:8]}") - check("no xref label is a bare '?'", - all(x != "?" for x in locs), f"locs={locs[:8]}") - await pilot.press("escape") - await wait_until(pilot, lambda: not isinstance(app.screen, XrefsScreen), 25) - - # Pre-selection: invoking 'x' at a call SITE highlights that very - # site in the dialog, so a long list can be stepped without losing - # your place. Use the decompiler (the exact-match seam). - bycaller = defaultdict(list) - for x in app.program.xrefs_to(multi.addr): - if x.fn_name and x.type == "code": - bycaller[x.fn_addr].append(x) - csites = next((sorted(v, key=lambda x: x.frm) - for v in bycaller.values() if len(v) >= 2), None) - if csites: - site = csites[len(csites) // 2] - await pilot.press("g") - await pilot.pause(0.1) - for ch in hex(site.fn_addr): - await pilot.press(ch) - await pilot.press("enter") - await wait_until(pilot, lambda: app._cur and app._cur.ea == site.fn_addr, 20) - if app._active != "decomp": - await pilot.press("tab") - await wait_until(pilot, lambda: dec.loaded_ea == site.fn_addr, 25) - li = app._decomp_line_for(site.fn_addr, site.frm) - col = dec._texts[li].find(multi.name) if 0 <= li < len(dec._texts) else -1 - if col >= 0: - dec.focus() - dec.cursor, dec.cursor_x = li, col + 1 - dec.refresh() - await pilot.pause(0.05) - await pilot.press("x") - await wait_until(pilot, lambda: isinstance(app.screen, XrefsScreen), 25) - hl = app.screen.query_one(OptionList).highlighted - it = app.screen._items - check("xref dialog pre-selects the site it was invoked from", - hl is not None and it[hl][0] == site.frm, - f"hl={hl} frm={hex(it[hl][0]) if hl is not None else None} " - f"want={hex(site.frm)}") - await pilot.press("escape") - await wait_until(pilot, lambda: not isinstance(app.screen, XrefsScreen), 25) - else: - check("found the callee token for preselect", False) - if app._active != "disasm": # restore for the following mouse test - await pilot.press("tab") - await wait_until(pilot, lambda: app._active == "disasm", 10) - else: - check("found a caller with multiple sites for preselect", False) - else: - check("found a function with multiple same-caller xrefs", False) - - # Mouse: single click places the cursor; double-click follows. - table.focus() - table.move_cursor(row=biggest_i) - await pilot.press("enter") - await wait_until(pilot, lambda: dis.total > 0, timeout=20) - dis.focus() - await pilot.pause(0.1) - mrow = mcol = msym = mline = None - for _ in range(40): # page down until a 'call sub_' is on screen - top = round(dis.scroll_offset.y) - dis.model.lines(top, dis.size.height + 2, prefetch=False) - for r in range(min(dis.size.height, dis.total - top)): - plain = dis._line_plain(top + r) - if plain and "call" in plain: - mm = re.search(r"\b(sub_[0-9A-Fa-f]+)", plain) - if mm: - mrow, mcol, msym, mline = r, mm.start(1), mm.group(1), top + r - break - if mrow is not None: - break - await pilot.press("pagedown") - await pilot.pause(0.025) - if mrow is None: - check("found a call line for the mouse test", False, "no visible call sub_") - else: - await pilot.click(dis, offset=(mcol + 1, mrow)) # +1: left padding - await pilot.pause(0.05) - check("single click places the cursor on the clicked token", - dis.cursor == mline and dis.word_under_cursor() == msym, - f"cursor={dis.cursor} (want {mline}) word={dis.word_under_cursor()!r}") - depth = len(app._nav) - want = app.program.resolve(msym) - await pilot.click(dis, offset=(mcol + 1, mrow), times=2) - await wait_until(pilot, lambda: len(app._nav) > depth, timeout=25) - check("double-click follows the symbol", app._cur.ea == want, - f"cur={app._cur.ea:#x} want={want:#x}") - # Back restores the exact cursor position (line AND column). - await pilot.press("escape") - await wait_until(pilot, lambda: app._cur.ea != want, timeout=20) - await wait_until(pilot, lambda: dis.total > 0 and dis.cursor == mline, timeout=20) - check("back restores the exact line + column", - dis.cursor == mline and dis.word_under_cursor() == msym, - f"cursor={dis.cursor} (want {mline}) word={dis.word_under_cursor()!r}") - - # Pseudocode-view position is tracked independently across jumps. - prog = app.program - fi = prog.functions() - fi.ensure(500) - pick = None - for fn in fi.all_loaded()[:500]: - d = prog.decompile(fn.addr) - if d.failed or not d.code: - continue - dl = d.code.split("\n") - if len(dl) < 12: - continue - for i, txt in enumerate(dl): - if i < 8: - continue - dm2 = re.search(r"\b(sub_[0-9A-Fa-f]+)", txt) - if dm2 and dm2.group(1) != fn.name: - pick = (fn, i, dm2.start(1), dm2.group(1)) - break - if pick: - break - if pick is None: - check("found a pseudocode line to test decomp nav", False) - else: - fn, drow, dcol, dsym = pick - await pilot.press("g") - await pilot.pause(0.1) - for ch in fn.name: - await pilot.press(ch) - await pilot.press("enter") - await wait_until(pilot, lambda: dis.total > 0, timeout=20) - await pilot.press("tab") - await wait_until(pilot, lambda: dec.loaded_ea == fn.addr, timeout=20) - dec.cursor = drow - dec.cursor_x = dcol - dec._after_cursor_move() - await pilot.pause(0.05) - depth = len(app._nav) - await pilot.press("enter") # follow the sym under the pseudocode cursor - await wait_until(pilot, lambda: len(app._nav) > depth, timeout=25) - await pilot.press("escape") - await wait_until(pilot, lambda: dec.loaded_ea == fn.addr, timeout=25) - await pilot.pause(0.1) - check("pseudocode-view position restored after jump+back", - dec.cursor == drow and dec.word_under_cursor() == dsym, - f"cursor={dec.cursor} (want {drow}) word={dec.word_under_cursor()!r}") - - # Follow must still work when the name is stale (as right after a - # rename, before the pseudocode text catches up): the ea-marker - # fallback follows by address regardless of the (old) token. - dstale = app.program.resolve(dsym) - old_line = dec._texts[drow] if drow < len(dec._texts) else "" - old_ea = dec._line_ea(drow) - if old_ea is not None and dsym in old_line: - tmpname = f"stale_{os.getpid()}" - app.program.client.call( - "rename", batch={"func": {"addr": hex(dstale), "name": tmpname}}) - app.program.bump_names() - d2 = len(app._nav) - # dsym is now the OLD name; follow must fall back to the line's ea - app._follow_decomp(old_line, dsym, old_ea) - await wait_until(pilot, lambda: len(app._nav) > d2, timeout=25) - check("decomp follow works with a stale name (ea-marker fallback)", - app._cur.ea == dstale, f"cur={app._cur.ea:#x} want={dstale:#x}") - app.program.client.call( - "rename", batch={"func": {"addr": hex(dstale), "name": dsym}}) - app.program.bump_names() - - # Column sort: click headers to sort by name / address. - if app._filter_term: - app._apply_filter("") - await pilot.pause(0.05) - await pilot.click(table, offset=(15, 0)) # Function header - await pilot.pause(0.15) - snames = [str(table.get_row_at(i)[1]) for i in range(min(20, table.row_count))] - check("click Function header sorts by name", - app._sort_col == 1 and snames == sorted(snames, key=str.lower), - f"sort_col={app._sort_col}") - first_asc = str(table.get_row_at(0)[1]) - await pilot.click(table, offset=(15, 0)) # reverse - await pilot.pause(0.15) - check("click again reverses the sort", - app._sort_reverse and str(table.get_row_at(0)[1]) != first_asc) - await pilot.click(table, offset=(3, 0)) # Address header - await pilot.pause(0.15) - saddrs = [int(str(table.get_row_at(i)[0]), 16) for i in range(min(20, table.row_count))] - check("click Address header sorts by address", - app._sort_col == 0 and saddrs == sorted(saddrs), f"sort_col={app._sort_col}") - - # Rename via 'n' (reuse the pseudocode sub_ ref found above). - if pick is not None: - fn, drow, dcol, dsym = pick - dtarget = app.program.resolve(dsym) - await pilot.press("g") - await pilot.pause(0.1) - for ch in fn.name: - await pilot.press(ch) - await pilot.press("enter") - await wait_until(pilot, lambda: dis.total > 0, timeout=20) - if app._active != "decomp": - await pilot.press("tab") - await wait_until(pilot, lambda: dec.loaded_ea == fn.addr, timeout=20) - dec.focus() - dec.cursor, dec.cursor_x = drow, dcol + 1 - dec.refresh() - await pilot.pause(0.05) - newname = f"ren_{os.getpid()}" - await pilot.press("n") - await pilot.pause(0.1) - ri = app.query_one("#rename", Input) - check("'n' opens the rename prompt prefilled with the symbol", - ri.display and ri.value == dsym, f"val={ri.value!r}") - ri.value = newname - await pilot.press("enter") - await wait_until( - pilot, - lambda: app._func_index.by_addr(dtarget) - and app._func_index.by_addr(dtarget).name == newname, - timeout=25, - ) - check("rename updates the function name", - app._func_index.by_addr(dtarget).name == newname, - app._func_index.by_addr(dtarget).name) - # revert via the API for reliable, race-free cleanup - rr = app.program.client.call( - "rename", batch={"func": {"addr": hex(dtarget), "name": dsym}}) - check("rename reverted cleanly", - rr.get("summary", {}).get("ok", 0) == 1, str(rr.get("summary"))) - - # A Hex-Rays goto label has no rename API; pressing 'n' on one must be - # refused up front with a clear message, not open a prompt that then - # fails with a misleading 'local variable not found'. - def _find_label(): - for i, t in enumerate(dec._texts): - mm = re.search(r"\bLABEL_\d+\b", t) - if mm: - return i, mm.start(), mm.group(0) - return None - lab = _find_label() - if lab is None: # current func has none; main reliably has labels - await pilot.press("g") - await pilot.pause(0.1) - for ch in "main": - await pilot.press(ch) - await pilot.press("enter") - await wait_until(pilot, lambda: app._cur and app._cur.name == "main", 20) - if app._active != "decomp": - await pilot.press("tab") - await wait_until(pilot, lambda: dec.loaded_ea == app._cur.ea, 25) - lab = _find_label() - if lab is not None: - li, lc, ltok = lab - dec.focus() - dec.cursor, dec.cursor_x = li, lc + 1 - dec.refresh() - await pilot.pause(0.05) - await pilot.press("n") - await pilot.pause(0.1) - ri2 = app.query_one("#rename", Input) - st = str(app.query_one("#status").render()) - check("renaming a pseudocode label is refused with a clear message", - (not ri2.display) and "label" in st.lower(), - f"display={ri2.display} status={st!r}") - else: - check("found a pseudocode label to test", False, "no LABEL_ found") - - # Add a comment on the current pseudocode line via ';' and confirm it - # renders after the decompiler refreshes. - cline = next((i for i in range(len(dec._texts)) - if i > 5 and dec._line_ea(i) is not None - and dec._texts[i].strip() and "//" not in dec._texts[i]), None) - if cline is not None: - cea = dec._line_ea(cline) - dec.focus() - dec.cursor, dec.cursor_x = cline, 2 - dec.refresh() - await pilot.pause(0.05) - await pilot.press("semicolon") - await pilot.pause(0.1) - ci = app.query_one("#comment", Input) - cnote = f"note_{os.getpid()}" - check("';' opens the comment prompt on the current line", ci.display, - f"display={ci.display}") - ci.value = cnote - await pilot.press("enter") - await wait_until( - pilot, lambda: dec.loaded_ea == app._cur.ea - and any(cnote in t for t in dec._texts), timeout=25) - check("comment appears in the pseudocode after ';'", - any(cnote in t for t in dec._texts), "comment not shown") - # revert via the API for clean, race-free cleanup - app.program.client.call( - "set_comments", items=[{"addr": hex(cea), "comment": ""}]) - else: - check("found a pseudocode line to comment", False, "no marker line") - - # Retype ('y') a FUNCTION prototype: the prompt prefills the current - # prototype (from the structured func_types tool) and applying a new - # one updates it. (Local-var retyping uses the same seam via - # set_lvar_type; it's not asserted here because Hex-Rays restructures - # some vars on retype, making a deterministic check fragile.) - cf = app._cur # whatever function is actually loaded now - await wait_until(pilot, lambda: dec.loaded_ea == cf.ea, 15) - fts = app.program.func_types(cf.ea) - if fts is not None and fts.prototype: - old_proto = fts.prototype - nm_col = dec._texts[0].find(cf.name) - dec.focus() - dec.cursor, dec.cursor_x = 0, (nm_col + 1 if nm_col >= 0 else 0) - dec.refresh() - await pilot.pause(0.05) - await pilot.press("y") - await wait_until(pilot, lambda: app.query_one("#retype", Input).display, 10) - ri = app.query_one("#retype", Input) - check("'y' on a function prefills its prototype", - ri.display and ri.value == old_proto, - f"val={ri.value!r} want={old_proto!r}") - ri.value = f"void __fastcall {cf.name}(int zz_retype_arg)" - await pilot.press("enter") - await wait_until( - pilot, lambda: (lambda f: bool(f) and "zz_retype_arg" in f.prototype)( - app.program.func_types(cf.ea)), 20) - after = app.program.func_types(cf.ea) - check("applying a retype changes the function prototype", - after is not None and "zz_retype_arg" in after.prototype, - f"proto={after.prototype if after else None!r}") - app.program.set_function_type(cf.ea, old_proto) # restore - else: - check("got structured function types (func_types tool)", False) - - # Decompiler follow of a name NOT in refs (the function's own name). - await pilot.press("g") - await pilot.pause(0.1) - for ch in fn.name: - await pilot.press(ch) - await pilot.press("enter") - await wait_until(pilot, lambda: dis.total > 0, timeout=20) - if app._active != "decomp": - await pilot.press("tab") - await wait_until(pilot, lambda: dec.loaded_ea == fn.addr, timeout=20) - nx = dec._texts[0].find(fn.name) if dec._texts else -1 - if nx >= 0: - dec.focus() - dec.cursor, dec.cursor_x = 0, nx + 1 - dec.refresh() - await pilot.pause(0.05) - depth = len(app._nav) - await pilot.press("enter") - moved = await wait_until(pilot, lambda: len(app._nav) > depth, timeout=25) - check("decompiler follows a name not in refs (resolve fallback)", - moved and app._cur.ea == fn.addr, f"moved={moved}") - - # Scroll position (not just the cursor) is restored on back, both views. - async def goto_name(name): - await pilot.press("g") - await pilot.pause(0.1) - for ch in name: - await pilot.press(ch) - await pilot.press("enter") - - # pick two distinct, decently-sized functions - big = sorted(fi.all_loaded(), key=lambda f: f.size, reverse=True) - fa = next((f for f in big if f.size > 0x400), big[0]) - fb = next((f for f in big if f.addr != fa.addr), big[-1]) - await goto_name(fa.name) - await wait_until(pilot, lambda: dis.total > 40 and app._cur.ea == fa.addr, timeout=20) - if app._active != "disasm": - await pilot.press("tab") - await pilot.pause(0.1) - for _ in range(4): - await pilot.press("ctrl+d") - await pilot.pause(0.1) - # Put the cursor in the MIDDLE of the viewport so the test is - # non-degenerate: with rel>0, restoring only the cursor (scroll-into-view) - # would derive a different scroll, so this actually checks scroll restore. - base = round(dis.scroll_offset.y) - mid = base + min(dis.size.height // 2, max(dis.total - base - 1, 0)) - dis.cursor, dis.cursor_x = mid, 0 - dis.refresh() - dis._after_cursor_move() - await pilot.pause(0.05) - want_sy, want_cur = round(dis.scroll_offset.y), dis.cursor - want_rel = want_cur - want_sy - await goto_name(fb.name) - await wait_until(pilot, lambda: app._cur.ea == fb.addr, timeout=20) - # Record the scroll at each repaint so we catch the "scroll_offset moved - # but the pane wasn't repainted" bug (which scroll_offset checks miss). - renders: list[int] = [] - _orig_rl = dis.render_line - def _traced(y, _o=_orig_rl): - if y == 0: - renders.append(round(dis.scroll_offset.y)) - return _o(y) - dis.render_line = _traced - await pilot.press("escape") - await wait_until(pilot, lambda: app._cur.ea == fa.addr, timeout=20) - await wait_until(pilot, lambda: dis.total > 40, timeout=20) - await pilot.pause(0.25) - check("disasm scroll + cursor restored on back (mid-viewport)", - round(dis.scroll_offset.y) == want_sy and dis.cursor == want_cur and want_rel > 0, - f"scroll={round(dis.scroll_offset.y)} (want {want_sy}) " - f"cursor={dis.cursor} (want {want_cur}) rel_before={want_rel}") - check("pane is repainted at the restored scroll (no stale top frame)", - bool(renders) and renders[-1] == want_sy, - f"last repaint scroll={renders[-1] if renders else None} (want {want_sy})") - dis.render_line = _orig_rl - - # PageUp/Down keep the cursor at the same viewport-relative row. - await goto_name(fa.name) - await wait_until(pilot, lambda: dis.total > 100 and app._cur.ea == fa.addr, timeout=20) - if app._active != "disasm": - await pilot.press("tab") - await pilot.pause(0.1) - for _ in range(6): - await pilot.press("j") - await pilot.pause(0.05) - rel = dis.cursor - round(dis.scroll_offset.y) - await pilot.press("pagedown") - await pilot.pause(0.05) - check("PageDown preserves the viewport-relative row", - dis.cursor - round(dis.scroll_offset.y) == rel, - f"rel={dis.cursor - round(dis.scroll_offset.y)} want={rel}") - await pilot.press("pageup") - await pilot.pause(0.05) - check("PageUp preserves the viewport-relative row", - dis.cursor - round(dis.scroll_offset.y) == rel, - f"rel={dis.cursor - round(dis.scroll_offset.y)} want={rel}") - - # Rename refresh across history: rename a callee while viewing it, then - # 'back' to the caller (cached earlier) shows the new name. - table.focus() - table.move_cursor(row=biggest_i) - await pilot.press("enter") - await wait_until(pilot, lambda: dis.total > 0, timeout=20) - bea = app._cur.ea - # cache the caller's pseudocode too, so the stale-decomp path is exercised - await pilot.press("tab") - await wait_until(pilot, lambda: dec.loaded_ea == bea, timeout=20) - await pilot.press("tab") - dis.focus() - await pilot.pause(0.1) - hrow = hsym = None - for _ in range(40): - top = round(dis.scroll_offset.y) - dis.model.lines(top, dis.size.height + 2, prefetch=False) - for r in range(min(dis.size.height, dis.total - top)): - p = dis._line_plain(top + r) - if p and "call sub_" in p: - mm = re.search(r"\bcall (sub_[0-9A-Fa-f]+)", p) - if mm: - hrow, hsym = top + r, mm.group(1) - break - if hrow is not None: - break - await pilot.press("pagedown") - await pilot.pause(0.025) - if hrow is not None: - htarget = app.program.resolve(hsym) - await pilot.press("g") - await pilot.pause(0.1) - for ch in hsym: - await pilot.press(ch) - await pilot.press("enter") - await wait_until(pilot, lambda: app._cur.ea == htarget, timeout=20) - if app._active != "decomp": - await pilot.press("tab") - await wait_until(pilot, lambda: dec.loaded_ea == htarget, timeout=20) - nx = dec._texts[0].find(hsym) if dec._texts else -1 - if nx >= 0: - dec.focus() - dec.cursor, dec.cursor_x = 0, nx + 1 - dec.refresh() - await pilot.pause(0.05) - hnew = f"h_{os.getpid()}" - await pilot.press("n") - await pilot.pause(0.1) - app.query_one("#rename", Input).value = hnew - await pilot.press("enter") - await wait_until( - pilot, - lambda: app._func_index.by_addr(htarget) - and app._func_index.by_addr(htarget).name == hnew, - timeout=25, - ) - if app._active != "disasm": - await pilot.press("tab") - await pilot.press("escape") - await wait_until( - pilot, lambda: dis.total > 0 and app._cur.ea != htarget, timeout=25) - await pilot.pause(0.2) - dis.model.lines(hrow, 4, prefetch=False) - await pilot.pause(0.1) - hline = dis._line_plain(hrow) - check("caller disasm shows renamed callee after 'back'", - hline is not None and hnew in hline, f"line={hline!r}") - # and the caller's cached pseudocode must refresh too - await pilot.press("tab") - await wait_until(pilot, lambda: dec.loaded_ea == bea, timeout=25) - await pilot.pause(0.15) - check("caller pseudocode shows renamed callee after 'back'", - any(hnew in tx for tx in dec._texts), - "pseudocode still stale") - app.program.client.call( - "rename", batch={"func": {"addr": hex(htarget), "name": hsym}}) - - -def main(argv): - global STOP_AFTER - db = None - it = iter(argv) - for a in it: - if a == "--db": - db = next(it) - elif a == "--stop-after": - # Iterate fast on one feature: run up to (and including) the first - # check whose name contains this substring, then stop (skips the - # expensive tail). Full run is the default (no flag). - STOP_AFTER = next(it) - try: - asyncio.run(run(db)) - except _StopSuite: - print(f" … stopped after '{STOP_AFTER}'") - print(f"\n{PASS} passed, {FAIL} failed") - return 1 if FAIL else 0 - - -if __name__ == "__main__": - raise SystemExit(main(sys.argv[1:])) |