macos/codeeditapp-codeedit/tests/test_ax_states.py

"""test_ax_states.py — CodeEdit AX STATE lane.

Owns CHECKED / ENABLED / SELECTED state and focus.  Every fact asserted here was
observed live on the official app under fresh-launch pytest conditions and is
recorded in recon.md `## STATE` (pristine profile — conftest wipes the app's
defaults before every launch, so the recorded values ARE the shipped defaults).

Contract: pytest methods on Test* classes taking the `ax` fixture, plain asserts,
every test declaring @pytest.mark.rb(depth=, jump_kind=, expect=) and backing a
`transition` with kit.rb_flip(...) / a `value` with kit.rb_value(...).
"""

# ── PRIMITIVES (verbatim from recon.md) ──────────────────────────────────────
import json
import os
import shutil
import subprocess
import time

import pytest

import rb_testgen_kit as kit
import verifier_helpers as helpers

RESULTS_DIR = os.environ.get("RESULTS_DIR", os.path.join(os.path.dirname(__file__), "results"))
FIXTURES_DIR = os.environ.get("FIXTURES_DIR") or os.path.join(os.path.dirname(__file__), "fixtures")


def screenshot_assert(test_name, description, results_dir=None):
    results_dir = results_dir or RESULTS_DIR
    ss_dir = os.path.join(results_dir, "screenshots")
    os.makedirs(ss_dir, exist_ok=True)
    ss_path = os.path.join(ss_dir, f"{test_name}.png")
    try:
        subprocess.run(["screencapture", "-x", ss_path], timeout=5)
    except Exception:
        pass
    af = os.path.join(ss_dir, "assertions.json")
    data = {}
    if os.path.exists(af):
        try:
            with open(af) as f:
                data = json.load(f)
        except Exception:
            data = {}
    data[f"{test_name}.png"] = description
    with open(af, "w") as f:
        json.dump(data, f, indent=2)


def win_id(ax, w):
    return ax.get(w.id, ["AXIdentifier"]).get("AXIdentifier")


def all_windows(ax):
    return ax.find(role="window", max_depth=1, max_results=20)


def find_window(ax, ident=None, title=None, timeout=8.0):
    end = time.time() + timeout
    while True:
        for w in all_windows(ax):
            if ident is not None and win_id(ax, w) == ident:
                return w
            if title is not None and (w.name or "") == title:
                return w
        if time.time() >= end:
            return None
        time.sleep(0.25)


def close_window(ax, w):
    if w is None:
        return False
    for b in ax.find(role="button", root_id=w.id, max_results=200, max_depth=3):
        if ax.get(b.id, ["AXSubrole"]).get("AXSubrole") == "AXCloseButton":
            ax.action(b.id, "AXPress")
            time.sleep(0.8)
            return True
    return False


def values_in(ax, root_id, max_results=400, max_depth=18):
    """Every non-empty AXValue string under root (labels, fields, popups)."""
    out = []
    for e in ax.find(root_id=root_id, max_results=max_results, max_depth=max_depth):
        v = ax.get(e.id, ["AXValue"]).get("AXValue")
        if isinstance(v, str) and v.strip():
            out.append(v)
    return out


def names_in(ax, root_id, role=None, max_results=400, max_depth=18):
    return [e.name for e in ax.find(role=role, root_id=root_id,
                                    max_results=max_results, max_depth=max_depth) if e.name]


def buttons_named(ax, root_id, name):
    return [b for b in ax.find(role="button", root_id=root_id, max_results=300, max_depth=16)
            if (b.name or "") == name]


def menu_item(ax, *path):
    mbi = [m for m in ax.find(role="menu_bar_item", max_results=20, max_depth=3)
           if (m.name or "") == path[0]]
    if not mbi:
        return None
    cur = mbi[0].id
    for label in path[1:]:
        items = ax.find(role="menu_item", root_id=cur, max_results=300, max_depth=2)
        hit = [i for i in items if (i.name or "") == label]
        if not hit:
            return None
        cur = hit[0].id
    return cur


def menu_items(ax, *path):
    """Item NAMES directly under a menu-bar item (or a submenu item)."""
    root = menu_item(ax, *path) if len(path) > 1 else None
    if root is None:
        mbi = [m for m in ax.find(role="menu_bar_item", max_results=20, max_depth=3)
               if (m.name or "") == path[0]]
        if not mbi:
            return []
        menus = ax.find(role="menu", root_id=mbi[0].id, max_results=2, max_depth=1)
        if not menus:
            return []
        root = menus[0].id
    else:
        menus = ax.find(role="menu", root_id=root, max_results=2, max_depth=1)
        if not menus:
            return []
        root = menus[0].id
    return [i.name for i in ax.find(role="menu_item", root_id=root, max_results=100, max_depth=1)
            if (i.name or "")]


def rb_enter_menu_item(ax, *path, wait=1.6):
    mid = menu_item(ax, *path)
    if mid is None:
        return False
    ax.action(mid, "AXPress")
    time.sleep(wait)
    return True


def rb_enter_welcome(ax):
    w = find_window(ax, ident="welcome", timeout=3)
    if w is None:
        rb_enter_menu_item(ax, "Window", "Welcome to CodeEdit")
        w = find_window(ax, ident="welcome", timeout=6)
    return w


def rb_enter_settings_window(ax):
    w = find_window(ax, ident="settings", timeout=1)
    if w is None:
        rb_enter_menu_item(ax, "CodeEdit", "Settings...", wait=2.0)
        w = find_window(ax, ident="settings", timeout=8)
    return w


def rb_reach_settings_pane(ax, pane):
    """Select a Settings sidebar pane. MUST be a CG click (AXPress does NOT select)."""
    w = rb_enter_settings_window(ax)
    if w is None:
        return None
    bs = buttons_named(ax, w.id, pane)
    if not bs:
        return None
    ax.click_element_cg(bs[-1].id)
    time.sleep(1.0)
    return find_window(ax, ident="settings", timeout=3)


def rb_enter_about_window(ax):
    rb_enter_menu_item(ax, "CodeEdit", "About CodeEdit", wait=2.0)
    return find_window(ax, ident="about", timeout=6)


def rb_enter_extensions_window(ax):
    rb_enter_menu_item(ax, "Extensions", "Open Extensions Window", wait=2.0)
    return find_window(ax, ident="extensions", timeout=6)


def rb_enter_clone_sheet(ax):
    w = rb_enter_welcome(ax)
    bs = buttons_named(ax, w.id, "Clone Git Repository...")
    if not bs:
        return None
    ax.action(bs[0].id, "AXPress")
    end = time.time() + 6
    while time.time() < end:
        s = ax.find(role="sheet", max_results=3, max_depth=6)
        if s:
            return s[0]
        time.sleep(0.25)
    return None


def rb_enter_save_panel(ax):
    w = rb_enter_welcome(ax)
    bs = buttons_named(ax, w.id, "Create New File...")
    if bs:
        ax.action(bs[0].id, "AXPress")
    return find_window(ax, title="Save", timeout=8)


def rb_enter_open_panel(ax):
    w = rb_enter_welcome(ax)
    bs = buttons_named(ax, w.id, "Open File or Folder...")
    if bs:
        ax.action(bs[0].id, "AXPress")
    return find_window(ax, title="Open Workspace or File", timeout=8)


def dismiss_panel_or_sheet(ax):
    """Escape does not work here — press the panel/sheet's own Cancel button."""
    for b in ax.find(role="button", max_results=120, max_depth=10):
        if (b.name or "") == "Cancel":
            ax.action(b.id, "AXPress")
            time.sleep(1.0)
            return True
    return False


def rb_enter_workspace(ax, folder_name="sample_project", timeout=20.0):
    """Open the fixture folder as a workspace the way Finder does: hand the folder to the
    RUNNING app's own bundle (discovered from its pid at runtime — portable)."""
    from AppKit import NSWorkspace, NSRunningApplication, NSWorkspaceOpenConfiguration
    from Foundation import NSURL
    src = os.path.join(FIXTURES_DIR, folder_name)
    base = os.path.join("/tmp", "rb_codeedit_ws")
    dst = os.path.join(base, folder_name)
    if os.path.isdir(base):
        shutil.rmtree(base, ignore_errors=True)
    os.makedirs(base, exist_ok=True)
    shutil.copytree(src, dst)
    ra = NSRunningApplication.runningApplicationWithProcessIdentifier_(int(ax._pid))
    cfg = NSWorkspaceOpenConfiguration.configuration()
    cfg.setActivates_(True)
    NSWorkspace.sharedWorkspace().openURLs_withApplicationAtURL_configuration_completionHandler_(
        [NSURL.fileURLWithPath_(dst)], ra.bundleURL(), cfg, None)
    return find_window(ax, ident="workspace", timeout=timeout)


def project_navigator(ax, ws):
    for o in ax.find(role="outline", root_id=ws.id, max_results=10, max_depth=14):
        if (o.name or "") == "Project Navigator":
            return o
    return None


def navigator_rows(ax, ws):
    nav = project_navigator(ax, ws)
    if nav is None:
        return []
    return [ax.get(t.id, ["AXValue"]).get("AXValue")
            for t in ax.find(role="text_field", root_id=nav.id, max_results=60, max_depth=8)]


def rb_reach_editor(ax, ws, filename):
    """Click a file row in the Project Navigator; returns the editor AXTextArea (or None)."""
    nav = project_navigator(ax, ws)
    if nav is None:
        return None
    rows = ax.find(role="text_field", root_id=nav.id, max_results=60, max_depth=8)
    tgt = [t for t in rows if ax.get(t.id, ["AXValue"]).get("AXValue") == filename]
    if not tgt:
        return None
    ax.click_element_cg(tgt[0].id)
    end = time.time() + 8
    while time.time() < end:
        ta = ax.find(role="text_area", root_id=ws.id, max_results=5, max_depth=18)
        if ta:
            return ta[0]
        time.sleep(0.3)
    return None


def rb_enter_command_palette(ax, ws):
    """Command Palette / Open Quickly only exist while a WORKSPACE window is open."""
    ax.action(ws.id, "AXRaise")
    time.sleep(0.5)
    rb_enter_menu_item(ax, "View", "Show Command Palette", wait=1.6)
    return _overlay_window(ax)


def rb_enter_open_quickly(ax, ws):
    ax.action(ws.id, "AXRaise")
    time.sleep(0.5)
    rb_enter_menu_item(ax, "File", "Open Quickly", wait=1.6)
    return _overlay_window(ax)


def _overlay_window(ax):
    """The palette/quick-open overlay is a borderless AXWindow: no title, no AXIdentifier."""
    for w in all_windows(ax):
        if win_id(ax, w) is None and not (w.name or ""):
            return w
    return None


def overlay_rows(ax, pal):
    return [v for v in (ax.get(t.id, ["AXValue"]).get("AXValue")
                        for t in ax.find(role="label", root_id=pal.id,
                                         max_results=60, max_depth=14)) if v]


def overlay_type(ax, pal, text):
    tf = ax.find(role="text_field", root_id=pal.id, max_results=5, max_depth=8)
    if not tf:
        return False
    ax.set_value(tf[0].id, text)
    time.sleep(1.3)
    return True


def switch_for_label(ax, root_id, label):
    """The AXCheckBox(AXSwitch) that follows the AXStaticText whose AXValue == label."""
    seq = ax.find(root_id=root_id, max_results=400, max_depth=18)
    idx = None
    for i, e in enumerate(seq):
        if e.role == "label" and ax.get(e.id, ["AXValue"]).get("AXValue") == label:
            idx = i
            break
    if idx is None:
        return None
    for e in seq[idx + 1:idx + 4]:
        if e.role == "checkbox":
            return e
    return None


def popup_for_label(ax, root_id, label):
    seq = ax.find(root_id=root_id, max_results=400, max_depth=18)
    idx = None
    for i, e in enumerate(seq):
        if e.role == "label" and ax.get(e.id, ["AXValue"]).get("AXValue") == label:
            idx = i
            break
    if idx is None:
        return None
    for e in seq[idx + 1:idx + 4]:
        if e.role == "popup":
            return e
    return None


def popup_options(ax, popup):
    ax.action(popup.id, "AXPress")
    time.sleep(0.8)
    menus = ax.find(role="menu", root_id=popup.id, max_results=3, max_depth=2)
    out = []
    if menus:
        for i in ax.find(role="menu_item", root_id=menus[0].id, max_results=40, max_depth=2):
            out.append(i.name or ax.get(i.id, ["AXValue"]).get("AXValue"))
        ax.action(menus[0].id, "AXCancel")
        time.sleep(0.4)
    return [o for o in out if o]


def popup_pick(ax, popup, option):
    ax.action(popup.id, "AXPress")
    time.sleep(0.8)
    menus = ax.find(role="menu", root_id=popup.id, max_results=3, max_depth=2)
    if not menus:
        return False
    for i in ax.find(role="menu_item", root_id=menus[0].id, max_results=40, max_depth=2):
        if (i.name or ax.get(i.id, ["AXValue"]).get("AXValue")) == option:
            ax.action(i.id, "AXPick")
            time.sleep(1.0)
            return True
    ax.action(menus[0].id, "AXCancel")
    return False
# ── end PRIMITIVES ───────────────────────────────────────────────────────────


# ── STATE-lane locators (semantic: visible label + role, never child index) ───

SETTLE = 0.9          # after a CG click on a SwiftUI switch/radio/segment
PANE_WALK = dict(max_results=400, max_depth=18)


def _norm(s):
    """Curly-quote / ellipsis tolerant, whitespace-trimmed label text."""
    return (str(s).replace("“", '"').replace("”", '"')
            .replace("‘", "'").replace("’", "'")
            .replace("…", "...").strip())


def _flag(v):
    """AXValue of a switch / radio / segment normalised to 1, 0 or None."""
    if v is None:
        return None
    if isinstance(v, bool):
        return int(v)
    if isinstance(v, (int, float)):
        return int(v)
    s = str(v).strip().lower()
    if s in ("1", "true", "yes", "on"):
        return 1
    if s in ("0", "false", "no", "off"):
        return 0
    return None


def _axval(ax, el):
    """Live AXValue of an element (None when the element was not found)."""
    if el is None:
        return None
    return ax.get(el.id, ["AXValue"]).get("AXValue")


def _boolish(v):
    """AXEnabled / AXFocused / AXSelected normalised to a real bool (None stays None).
    The AX bridge may hand back 1/0 or True/False depending on the toolkit."""
    if v is None:
        return None
    if isinstance(v, bool):
        return v
    if isinstance(v, (int, float)):
        return bool(v)
    s = str(v).strip().lower()
    if s in ("1", "true", "yes"):
        return True
    if s in ("0", "false", "no"):
        return False
    return None


def _texts(ax, e):
    """Every visible-text candidate for an element: AXValue then AXTitle/AXDescription."""
    out = []
    v = e.value
    if isinstance(v, str) and v:
        out.append(v)
    if e.name:
        out.append(str(e.name))
    if not out:
        v2 = ax.get(e.id, ["AXValue"]).get("AXValue")
        if isinstance(v2, str) and v2:
            out.append(v2)
    return out


def _pane_seq(ax, root_id):
    """Pre-order element sequence of a settings pane (one tree walk per read)."""
    return ax.find(root_id=root_id, **PANE_WALK)


def _label_index(ax, seq, label):
    """Index of the static text carrying `label` — exact, then trimmed, then
    curly-quote-normalised (a recreation may use straight quotes / trim spaces)."""
    cands = [(i, _texts(ax, e)) for i, e in enumerate(seq) if e.role == "label"]
    for i, ts in cands:
        if any(t == label for t in ts):
            return i
    for i, ts in cands:
        if any(t.strip() == label.strip() for t in ts):
            return i
    tgt = _norm(label)
    for i, ts in cands:
        if any(_norm(t) == tgt for t in ts):
            return i
    return None


def _control_after(ax, seq, label, role, window=4):
    """The control of `role` that immediately follows the row label (SwiftUI Form order)."""
    i = _label_index(ax, seq, label)
    if i is None:
        return None
    for e in seq[i + 1:i + 1 + window]:
        if e.role == role:
            return e
    return None


def _switch_in(ax, seq, label, root_id=None):
    """AXCheckBox/AXSwitch for a row label; falls back to the PRIMITIVES locator."""
    el = _control_after(ax, seq, label, "checkbox")
    if el is None and root_id is not None:
        el = switch_for_label(ax, root_id, label)
    return el


def _popup_in(ax, seq, label, root_id=None):
    """AXPopUpButton for a row label; falls back to the PRIMITIVES locator."""
    el = _control_after(ax, seq, label, "popup")
    if el is None and root_id is not None:
        el = popup_for_label(ax, root_id, label)
    return el


def _field_in(ax, seq, label):
    return _control_after(ax, seq, label, "text_field")


def _switch_flags(ax, seq, labels, root_id=None):
    return {lbl: _flag(_axval(ax, _switch_in(ax, seq, lbl, root_id))) for lbl in labels}


def _popup_values(ax, seq, labels, root_id=None):
    out = {}
    for lbl in labels:
        v = _axval(ax, _popup_in(ax, seq, lbl, root_id))
        out[lbl] = str(v) if isinstance(v, str) else v
    return out


def _field_values(ax, seq, labels):
    out = {}
    for lbl in labels:
        v = _axval(ax, _field_in(ax, seq, lbl))
        out[lbl] = str(v) if v is not None else None
    return out


def _radios(ax, root_id):
    """name -> first AXRadioButton/segment with that name under root."""
    out = {}
    for r in ax.find(role="radio", root_id=root_id, max_results=60, max_depth=18):
        nm = (r.name or "").strip()
        if nm and nm not in out:
            out[nm] = r
    return out


def _radio_flags(ax, root_id, names):
    rs = _radios(ax, root_id)
    return {n: _flag(_axval(ax, rs.get(n))) for n in names}


def _group_with(ax, root_id, names):
    """The AXRadioGroup / segmented control under root whose radios carry ALL `names`.
    Scoping every read to that group keeps a same-named element elsewhere in the window
    (e.g. the sidebar's 'General' pane row) out of the measurement."""
    want = {n.strip() for n in names}
    for g in ax.find(role="radiogroup", root_id=root_id, max_results=20, max_depth=18):
        got = {(r.name or "").strip()
               for r in ax.find(role="radio", root_id=g.id, max_results=12, max_depth=4)}
        if want <= got:
            return g
    return None


def _radio_group_for(ax, seq, label, member_names):
    """The AXRadioGroup belonging to `label`.

    Both `Navigator Tab Bar Position` and `Inspector Tab Bar Position` own a Top/Side
    pair, so member names alone are ambiguous. Pick, among the groups that DO carry
    `member_names`, the one nearest the row label in tree order (a recreation may emit
    the group just before or just after its label); recon records the Navigator group
    first, so fall back to first-vs-last if no label is found at all."""
    want = {n.strip() for n in member_names}
    cands = []
    for i, e in enumerate(seq):
        if e.role != "radiogroup":
            continue
        got = {(r.name or "").strip()
               for r in ax.find(role="radio", root_id=e.id, max_results=10, max_depth=4)}
        if want <= got:
            cands.append((i, e))
    if not cands:
        return None
    li = _label_index(ax, seq, label)
    if li is None:
        return cands[0][1] if "Navigator" in label else cands[-1][1]
    after = [(i, e) for i, e in cands if i >= li]
    if after:
        return min(after, key=lambda p: p[0] - li)[1]
    return min(cands, key=lambda p: abs(p[0] - li))[1]


def _has_text(ax, seq, needle):
    n = _norm(needle).lower()
    for e in seq:
        for t in _texts(ax, e):
            if n in _norm(t).lower():
                return True
    return False


def _selected_rows(ax, w):
    """Visible-text blob of every sidebar row currently AXSelected.

    recon: the selected pane's AXRow/AXCell carries AXSelected == True. Rows are
    tried first; only if NO row reports the selection do we fall back to cells, so a
    selected row plus its selected cell can never be counted twice."""
    def _sel(role):
        out = []
        for r in ax.find(role=role, root_id=w, max_results=80, max_depth=16):
            if _boolish(ax.get(r.id, ["AXSelected"]).get("AXSelected")) is True:
                parts = []
                for e in ax.find(root_id=r.id, max_results=20, max_depth=6):
                    ts = _texts(ax, e)
                    if ts:
                        parts.append(ts[0])
                out.append(" ".join(parts).strip())
        return out

    return _sel("row") or _sel("cell")


def _menu_enabled(ax, menu_name, item_names):
    """{item -> AXEnabled} for items directly under a menu-bar menu (None if absent)."""
    mbi = [m for m in ax.find(role="menu_bar_item", max_results=20, max_depth=3)
           if (m.name or "") == menu_name]
    if not mbi:
        return {n: None for n in item_names}
    by_name = {}
    for i in ax.find(role="menu_item", root_id=mbi[0].id, max_results=300, max_depth=2):
        nm = (i.name or "").strip()
        if nm and nm not in by_name:
            by_name[nm] = i
    out = {}
    for n in item_names:
        el = by_name.get(n)
        out[n] = None if el is None else _boolish(
            ax.get(el.id, ["AXEnabled"]).get("AXEnabled"))
    return out


def rb_enter_popup_options(ax, popup):
    """Open a popup button's MENU — a new AX surface — and read its option list."""
    return popup_options(ax, popup)


# ── recorded shipped defaults (recon ## STATE, pristine profile) ─────────────

GENERAL_SWITCH_DEFAULTS = {
    "Show Path Bar": 1,
    "Dim editors without focus": 0,
    "Show Live Issues": 1,
    "Automatically save changes to disk": 1,
    "Automatically reveal in project navigator": 0,
    # curly quotes in the shipped label
    "Show “Open With CodeEdit” option in Finder": 1,
    "Automatically check for app updates": 0,
}

GENERAL_POPUP_DEFAULTS = {
    "Appearance": "System",
    "Show Issues": "Show Inline",
    "Reopen Behavior": "Welcome Screen",
    "After the last window is closed": "Do nothing",
    "File Extensions": "Show all",
    "Project Navigator Size": "Medium",
    "Find Navigator Detail": "Up to 3 lines",
}

FIND_MENU_ITEMS = ["Find...", "Find and Replace...", "Find Next", "Find Previous",
                   "Use Selection for Find", "Jump to Selection"]

SOURCE_CONTROL_MENU_ITEMS = ["Commit...", "Push...", "Pull...", "Fetch Changes",
                             "Stage All Changes", "Unstage All Changes", "Cherry-Pick...",
                             "Stash Changes...", "Discard All Changes...",
                             "Add Exisiting Remote..."]


# ── General pane: shipped defaults (value) ───────────────────────────────────

class TestGeneralPaneDefaults:

    @pytest.mark.rb(depth=1, jump_kind="value",
                    expect="Settings>General switches on a pristine profile: Show Path Bar=1, "
                           "Dim editors without focus=0, Show Live Issues=1, Automatically save "
                           "changes to disk=1, Automatically reveal in project navigator=0, "
                           "Show “Open With CodeEdit” option in Finder=1, "
                           "Automatically check for app updates=0")
    def test_general_pane_switch_defaults(self, ax):
        w = rb_reach_settings_pane(ax, "General")
        assert w is not None, "Settings window / General pane not reachable"
        seq = _pane_seq(ax, w.id)
        observed = _switch_flags(ax, seq, list(GENERAL_SWITCH_DEFAULTS), w.id)
        assert kit.rb_value(observed, GENERAL_SWITCH_DEFAULTS), (
            f"General switch defaults mismatch: observed={observed} "
            f"expected={GENERAL_SWITCH_DEFAULTS}")

    @pytest.mark.rb(depth=1, jump_kind="value",
                    expect="Settings>General popups default to Appearance=System, Show Issues="
                           "Show Inline, Reopen Behavior=Welcome Screen, After the last window "
                           "is closed=Do nothing, File Extensions=Show all, Project Navigator "
                           "Size=Medium, Find Navigator Detail=Up to 3 lines")
    def test_general_pane_popup_defaults(self, ax):
        w = rb_reach_settings_pane(ax, "General")
        assert w is not None, "Settings window / General pane not reachable"
        seq = _pane_seq(ax, w.id)
        observed = _popup_values(ax, seq, list(GENERAL_POPUP_DEFAULTS), w.id)
        assert kit.rb_value(observed, GENERAL_POPUP_DEFAULTS), (
            f"General popup defaults mismatch: observed={observed} "
            f"expected={GENERAL_POPUP_DEFAULTS}")


# ── Switch flips: read → CG click → read (transition) ────────────────────────

class TestSwitchFlips:

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="'Dim editors without focus' AXValue flips 0 -> 1 after a CG click "
                           "on its switch in Settings>General")
    def test_dim_editors_without_focus_switch_turns_on(self, ax):
        label = "Dim editors without focus"
        w = rb_reach_settings_pane(ax, "General")
        assert w is not None, "Settings window / General pane not reachable"
        sw = _switch_in(ax, _pane_seq(ax, w.id), label, w.id)
        assert sw is not None, f"no AXCheckBox/AXSwitch found for label {label!r}"
        before = _flag(_axval(ax, sw))
        ax.click_element_cg(sw.id)
        time.sleep(SETTLE)
        after = _flag(_axval(ax, _switch_in(ax, _pane_seq(ax, w.id), label, w.id)))
        screenshot_assert(
            "state_test_dim_editors_switch_on",
            "CodeEdit Settings window, General pane. The 'Dim editors without focus' toggle "
            "switch is now ON (knob slid to the right, track filled with the blue accent "
            "colour); the 'Show Path Bar' switch directly above it is still ON and every other "
            "row (Appearance popup showing 'System', the Color/Monochrome File Icon Style "
            "radio pair with Color selected) is unchanged.")
        assert kit.rb_flip(before, after) and before == 0 and after == 1, (
            f"'{label}' switch did not flip 0->1: before={before} after={after}")

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="'Show Path Bar' AXValue flips 1 -> 0 after a CG click on its switch "
                           "in Settings>General")
    def test_show_path_bar_switch_turns_off(self, ax):
        label = "Show Path Bar"
        w = rb_reach_settings_pane(ax, "General")
        assert w is not None, "Settings window / General pane not reachable"
        sw = _switch_in(ax, _pane_seq(ax, w.id), label, w.id)
        assert sw is not None, f"no AXCheckBox/AXSwitch found for label {label!r}"
        before = _flag(_axval(ax, sw))
        ax.click_element_cg(sw.id)
        time.sleep(SETTLE)
        after = _flag(_axval(ax, _switch_in(ax, _pane_seq(ax, w.id), label, w.id)))
        assert kit.rb_flip(before, after) and before == 1 and after == 0, (
            f"'{label}' switch did not flip 1->0: before={before} after={after}")

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="'Show Live Issues' AXValue flips 1 -> 0 after a CG click on its "
                           "switch in Settings>General")
    def test_show_live_issues_switch_turns_off(self, ax):
        label = "Show Live Issues"
        w = rb_reach_settings_pane(ax, "General")
        assert w is not None, "Settings window / General pane not reachable"
        sw = _switch_in(ax, _pane_seq(ax, w.id), label, w.id)
        assert sw is not None, f"no AXCheckBox/AXSwitch found for label {label!r}"
        before = _flag(_axval(ax, sw))
        ax.click_element_cg(sw.id)
        time.sleep(SETTLE)
        after = _flag(_axval(ax, _switch_in(ax, _pane_seq(ax, w.id), label, w.id)))
        assert kit.rb_flip(before, after) and before == 1 and after == 0, (
            f"'{label}' switch did not flip 1->0: before={before} after={after}")


# ── Radio groups: exactly one member checked, and it moves (transition) ──────

class TestRadioGroups:

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="File Icon Style radio selection moves: Color 1/Monochrome 0 -> "
                           "Color 0/Monochrome 1 (exactly one selected before and after)")
    def test_file_icon_style_radio_moves_to_monochrome(self, ax):
        w = rb_reach_settings_pane(ax, "General")
        assert w is not None, "Settings window / General pane not reachable"
        rs = _radios(ax, w.id)
        assert "Color" in rs and "Monochrome" in rs, (
            f"File Icon Style radios not found; radios present: {sorted(rs)}")
        before = (_flag(_axval(ax, rs["Color"])), _flag(_axval(ax, rs["Monochrome"])))
        ax.click_element_cg(rs["Monochrome"].id)
        time.sleep(SETTLE)
        after = tuple(_radio_flags(ax, w.id, ["Color", "Monochrome"]).values())
        screenshot_assert(
            "state_test_file_icon_style_monochrome",
            "CodeEdit Settings window, General pane. In the 'File Icon Style' radio pair the "
            "'Monochrome' radio button is now filled/selected and 'Color' is empty, so the "
            "file icons render in a single grey tone. The Appearance popup above still reads "
            "'System' and the Navigator Tab Bar Position pair below still has 'Top' selected.")
        assert kit.rb_flip(before, after) and before == (1, 0) and after == (0, 1), (
            f"File Icon Style selection did not move Color->Monochrome: "
            f"before={before} after={after}")

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="Navigator Tab Bar Position radio selection moves Top 1/Side 0 -> "
                           "Top 0/Side 1 after a CG click on 'Side'")
    def test_navigator_tab_bar_position_radio_moves_to_side(self, ax):
        w = rb_reach_settings_pane(ax, "General")
        assert w is not None, "Settings window / General pane not reachable"
        grp = _radio_group_for(ax, _pane_seq(ax, w.id),
                               "Navigator Tab Bar Position", ["Top", "Side"])
        assert grp is not None, "Navigator Tab Bar Position radio group not found"
        before = tuple(_radio_flags(ax, grp.id, ["Top", "Side"]).values())
        side = _radios(ax, grp.id).get("Side")
        assert side is not None, "no 'Side' radio inside the Navigator Tab Bar Position group"
        ax.click_element_cg(side.id)
        time.sleep(SETTLE)
        after = tuple(_radio_flags(ax, grp.id, ["Top", "Side"]).values())
        assert kit.rb_flip(before, after) and before == (1, 0) and after == (0, 1), (
            f"Navigator Tab Bar Position did not move Top->Side: before={before} after={after}")


# ── Popup buttons: selected value + option list ──────────────────────────────

class TestPopupState:

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="'Project Navigator Size' popup value flips Medium -> Large after "
                           "AXPress + AXPick on the 'Large' menu item")
    def test_project_navigator_size_popup_picks_large(self, ax):
        label = "Project Navigator Size"
        w = rb_reach_settings_pane(ax, "General")
        assert w is not None, "Settings window / General pane not reachable"
        pu = _popup_in(ax, _pane_seq(ax, w.id), label, w.id)
        assert pu is not None, f"no AXPopUpButton found for label {label!r}"
        before = _axval(ax, pu)
        assert popup_pick(ax, pu, "Large"), "'Large' option not offered by the popup menu"
        after = _axval(ax, _popup_in(ax, _pane_seq(ax, w.id), label, w.id))
        assert kit.rb_flip(before, after) and before == "Medium" and after == "Large", (
            f"'{label}' popup did not change Medium->Large: before={before!r} after={after!r}")

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="'Appearance' popup value flips System -> Dark after AXPress + "
                           "AXPick on the 'Dark' menu item")
    def test_appearance_popup_picks_dark(self, ax):
        label = "Appearance"
        w = rb_reach_settings_pane(ax, "General")
        assert w is not None, "Settings window / General pane not reachable"
        pu = _popup_in(ax, _pane_seq(ax, w.id), label, w.id)
        assert pu is not None, f"no AXPopUpButton found for label {label!r}"
        before = _axval(ax, pu)
        assert popup_pick(ax, pu, "Dark"), "'Dark' option not offered by the Appearance popup"
        after = _axval(ax, _popup_in(ax, _pane_seq(ax, w.id), label, w.id))
        assert kit.rb_flip(before, after) and before == "System" and after == "Dark", (
            f"'{label}' popup did not change System->Dark: before={before!r} after={after!r}")

    @pytest.mark.rb(depth=2, jump_kind="value",
                    expect="the Appearance popup's own menu (a second surface) lists exactly "
                           "System, Light, Dark")
    def test_appearance_popup_option_list(self, ax):
        w = rb_reach_settings_pane(ax, "General")
        assert w is not None, "Settings window / General pane not reachable"
        pu = _popup_in(ax, _pane_seq(ax, w.id), "Appearance", w.id)
        assert pu is not None, "no AXPopUpButton found for label 'Appearance'"
        observed = [str(o) for o in rb_enter_popup_options(ax, pu)]
        assert kit.rb_value(observed, ["System", "Light", "Dark"]), (
            f"Appearance popup options mismatch: observed={observed} "
            f"expected=['System', 'Light', 'Dark']")


# ── Segmented controls (AXRadioGroup of AXSegments) ──────────────────────────

class TestSegmentedControls:

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="Source Control segmented control flips General 1/Git 0 -> General "
                           "0/Git 1 and the pane content swaps in the Git fields (Author Name / "
                           "Author Email)")
    def test_source_control_segment_switches_to_git(self, ax):
        w = rb_reach_settings_pane(ax, "Source Control")
        assert w is not None, "Settings window / Source Control pane not reachable"
        seq = _pane_seq(ax, w.id)
        rs = _radios(ax, w.id)
        assert "General" in rs and "Git" in rs, (
            f"Source Control segments not found; radios present: {sorted(rs)}")
        before = (_flag(_axval(ax, rs["General"])), _flag(_axval(ax, rs["Git"])),
                  _has_text(ax, seq, "Author Name"))
        ax.click_element_cg(rs["Git"].id)
        time.sleep(SETTLE + 0.4)
        seq2 = _pane_seq(ax, w.id)
        flags = _radio_flags(ax, w.id, ["General", "Git"])
        after = (flags["General"], flags["Git"],
                 _has_text(ax, seq2, "Author Name") and _has_text(ax, seq2, "Author Email"))
        assert kit.rb_flip(before, after) and before == (1, 0, False) and after == (0, 1, True), (
            f"Source Control segment did not switch to Git: before={before} after={after}")



# ── Per-pane shipped default state (value) ───────────────────────────────────

class TestPaneDefaultState:

    @pytest.mark.rb(depth=1, jump_kind="value",
                    expect="Settings>Themes switches default to Automatically change theme "
                           "based on system appearance=1, Always use dark terminal "
                           "appearance=0, Use theme background=1")
    def test_themes_pane_switch_defaults(self, ax):
        w = rb_reach_settings_pane(ax, "Themes")
        assert w is not None, "Settings window / Themes pane not reachable"
        seq = _pane_seq(ax, w.id)
        expected = {
            "Automatically change theme based on system appearance": 1,
            "Always use dark terminal appearance": 0,
            # shipped label carries a trailing space — matched trim-tolerantly
            "Use theme background": 1,
        }
        observed = _switch_flags(ax, seq, list(expected), w.id)
        assert kit.rb_value(observed, expected), (
            f"Themes switch defaults mismatch: observed={observed} expected={expected}")

    @pytest.mark.rb(depth=1, jump_kind="value",
                    expect="Settings>Terminal defaults: Shell=System Default, Terminal Cursor "
                           "Style=Block, Use \"Option\" key as \"Meta\"=0, Use text editor "
                           "font=1, Blink Cursor=0, Shell Integration=1, Use Login Shell=1")
    def test_terminal_pane_control_defaults(self, ax):
        w = rb_reach_settings_pane(ax, "Terminal")
        assert w is not None, "Settings window / Terminal pane not reachable"
        seq = _pane_seq(ax, w.id)
        expected_sw = {
            "Use \"Option\" key as \"Meta\"": 0,
            "Use text editor font": 1,
            "Blink Cursor": 0,
            "Shell Integration": 1,
            "Use Login Shell": 1,
        }
        expected_pu = {"Shell": "System Default", "Terminal Cursor Style": "Block"}
        observed = dict(_switch_flags(ax, seq, list(expected_sw), w.id))
        observed.update(_popup_values(ax, seq, list(expected_pu), w.id))
        expected = dict(expected_sw)
        expected.update(expected_pu)
        assert kit.rb_value(observed, expected), (
            f"Terminal pane defaults mismatch: observed={observed} expected={expected}")


    @pytest.mark.rb(depth=1, jump_kind="value",
                    expect="Settings>Source Control (General segment) defaults: Enable source "
                           "control=1, Show source control changes=1, the four automatic "
                           "switches=0, Include upstream changes=0 and Default branch name=main")
    def test_source_control_general_defaults(self, ax):
        w = rb_reach_settings_pane(ax, "Source Control")
        assert w is not None, "Settings window / Source Control pane not reachable"
        seq = _pane_seq(ax, w.id)
        expected_sw = {
            "Enable source control": 1,
            "Refresh local status automatically": 0,
            "Fetch and refresh server status automatically": 0,
            "Add and remove files automatically": 0,
            "Select files to commit automatically": 0,
            "Show source control changes": 1,
            "Include upstream changes": 0,
        }
        expected_pu = {"Comparison view": "Local Revision on Left Side",
                       "Source control navigator": "Sort by Name"}
        expected_fl = {"Default branch name": "main"}
        observed = dict(_switch_flags(ax, seq, list(expected_sw), w.id))
        observed.update(_popup_values(ax, seq, list(expected_pu), w.id))
        observed.update(_field_values(ax, seq, list(expected_fl)))
        expected = dict(expected_sw)
        expected.update(expected_pu)
        expected.update(expected_fl)
        assert kit.rb_value(observed, expected), (
            f"Source Control General defaults mismatch: observed={observed} "
            f"expected={expected}")


# ── Sidebar selection state (exactly one row AXSelected) ─────────────────────

class TestSelectionState:

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="Settings sidebar selection moves General -> Themes: exactly one "
                           "AXRow/AXCell is AXSelected at a time and the window title equals "
                           "the selected pane name")
    def test_settings_sidebar_selection_follows_pane(self, ax):
        w1 = rb_reach_settings_pane(ax, "General")
        assert w1 is not None, "Settings window / General pane not reachable"
        sel1 = _selected_rows(ax, w1.id)
        before = ((w1.name or ""), tuple(sel1))
        w2 = rb_reach_settings_pane(ax, "Themes")
        assert w2 is not None, "Settings window lost after selecting the Themes pane"
        sel2 = _selected_rows(ax, w2.id)
        after = ((w2.name or ""), tuple(sel2))
        ok_shape = (len(sel1) == 1 and len(sel2) == 1
                    and "General" in sel1[0] and "Themes" in sel2[0]
                    and (w1.name or "") == "General" and (w2.name or "") == "Themes")
        assert kit.rb_flip(before, after) and ok_shape, (
            f"Settings sidebar selection did not move General->Themes: "
            f"before={before} after={after}")


# ── Menu enabled-state at fresh launch (value, depth 0) ─────────────────────

class TestMenuEnabledState:

    @pytest.mark.rb(depth=0, jump_kind="value",
                    expect="at fresh launch all 6 Find menu items and all 10 Source Control "
                           "menu items report AXEnabled == False (no workspace / no repository)")
    def test_find_and_source_control_menu_items_disabled(self, ax):
        observed = {}
        for k, v in _menu_enabled(ax, "Find", FIND_MENU_ITEMS).items():
            observed[f"Find > {k}"] = v
        for k, v in _menu_enabled(ax, "Source Control", SOURCE_CONTROL_MENU_ITEMS).items():
            observed[f"Source Control > {k}"] = v
        expected = {k: False for k in observed}
        expected_full = {f"Find > {n}": False for n in FIND_MENU_ITEMS}
        expected_full.update({f"Source Control > {n}": False
                              for n in SOURCE_CONTROL_MENU_ITEMS})
        assert kit.rb_value(observed, expected_full), (
            f"fresh-launch disabled set mismatch: observed={observed} "
            f"expected={expected_full} (keys seen: {sorted(expected)})")

    @pytest.mark.rb(depth=0, jump_kind="value",
                    expect="File menu at fresh launch: Close Workspace and Workspace Settings "
                           "are AXEnabled False while New, Open... and Save are enabled")
    def test_file_menu_workspace_items_disabled_but_new_enabled(self, ax):
        items = ["New", "Open...", "Save", "Close Workspace", "Workspace Settings"]
        observed = _menu_enabled(ax, "File", items)
        expected = {"New": True, "Open...": True, "Save": True,
                    "Close Workspace": False, "Workspace Settings": False}
        assert kit.rb_value(observed, expected), (
            f"File menu enabled-state mismatch: observed={observed} expected={expected}")


# ── Focus + context-sensitive enablement behind a workspace (depth 2) ────────