wine-access/tests/README.md

# Wine control integration

## Temporary files and failure inspection

Wine CTests and the integration scripts below use fresh prefixes under the
temporary directory (`/tmp` by default). Successful runs stop their Wine
servers and remove their temporary files. **Failures, timeouts and ordinary
interruptions retain the original files by default**, with the directory path
printed before the test starts and again at exit. This preserves a one-off
failure for inspection without requiring a second reproduction. Retention
keeps files and registry state; test processes are still stopped.

Console output and fixture `.log` files are saved under
`<build-dir>/Testing/WineAccessLogs/`, outside the disposable prefix. These logs
remain even when temporary files are removed. CTest also keeps its usual
`Testing/Temporary/LastTest.log` report. Saved logs need occasional maintenance;
review them for private text before sharing.

To retain successful runs too, or explicitly clean a failed run:

```sh
xvfb-run -a python3 tests/menu_integration.py --build-dir build --keep
xvfb-run -a python3 tests/menu_integration.py --build-dir build --clean-on-failure
WINE_ACCESS_TEST_KEEP=1 xvfb-run -a ctest --test-dir build -V
WINE_ACCESS_TEST_KEEP_ON_FAILURE=0 xvfb-run -a ctest --test-dir build --output-on-failure
```

Each run requires at least 1024 MiB free on the temporary filesystem before
starting. If retained failures accumulate, the next run stops with an explicit
space error; it never deletes earlier evidence automatically. Remove retained
directories manually after inspecting them. `TMPDIR` can select another
filesystem, and `WINE_ACCESS_TEST_MIN_FREE_MIB` can adjust the space guard for
larger fixtures. CTests run serially because their fixtures share one display.
A teardown or log-preservation failure always retains the temporary files.
SIGKILL, machine shutdown and an outer test-runner kill cannot run Python
cleanup; occasional `/tmp` cleanup remains useful.

Check the runner without Wine:

```sh
python3 tests/wine_test_environment_test.py
```

## Battle.net bootstrapper controls

```sh
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture bootstrapper --32-bit
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture bootstrapper
```

Run these sequentially. The fixture supplies an actual custom UIA provider
without native child controls. A private recording reader verifies language
value changes, Continue focus despite a radio item retaining its focus flag,
return to the selector, duplicate suppression, background exclusion and return,
and exclusion of protected or unknown-protection values before querying them.
The real native input hook also reads a Toggle provider whose state is absent
from the provider's simple properties. It checks unchecked, checked and mixed
states, changes without focus movement, focus return and background exclusion.
The fixture fails if the helper invokes Toggle rather than reading its state.
The test does not use the real installer or send speech to the running reader.

Read-only inspection on October 16 retrieved the actual running setup's
`Select a Language, combo box, English (United States)` and `Continue, push
button` through the new query code during Tab navigation. This verifies the
query path, not installed-helper speech or physical Braille.

A later read-only native probe on the second page retrieved the startup
checkbox's real Toggle state while Wine's client state query returned
`E_NOTIMPL`. The first installed build was confirmed by the user to read the
language page and allow progress to the second screen; audible checkbox-state
acceptance remains separate.

After building/installing Wine Access, restart Cthulhu and reopen the wizard
to load the new native hook. Return to the
wizard on workspace 2. Tab/Shift+Tab should distinguish the language selector
from Continue. With the selector focused, Down/Up should announce the current
language; restore the intended language afterward. Pause to check for repeated
announcements, then switch to Linux and back to check background silence and
focus recovery. Only activate Continue when ready to advance the installer;
later pages and the launcher remain unverified. Check ordinary Wine Notepad
typing/arrows, menus/Escape, native combo-box arrows and reader shutdown for
regressions. Verify audible speech and physical Braille separately.

On the second page, Tab to `Launch Battle.net when you start your computer`:
expect its current checked/unchecked state. Press Space twice and verify each
new state immediately, leaving the original setting restored. Tab away and
Shift+Tab back should retain the correct state. Switching away must silence
background changes; returning should reestablish the state. Choose the desired
startup setting before continuing installation.

## UIA notifications

UIA notification routing uses the actual native application hooks and a private
recording reader, without sending speech to the live reader:

```sh
xvfb-run -a python3 tests/notification_integration.py --build-dir build
xvfb-run -a python3 tests/notification_integration.py --build-dir build --32-bit --reader orca
```

To exercise a real 64-bit Prism DLL through its UIA backend, provide the matching
Prism C headers (`prism.h` and `prism_version.h`) without replacing the DLL:

```sh
xvfb-run -a python3 tests/notification_integration.py --build-dir build \
  --prism-dll /path/to/prism.dll --prism-include /path/to/prism/headers
```

These checks cover Unicode text, interruption, empty-message cancellation,
bounded payloads, and ignoring a background application's announcements. They
do not establish audible speech. After installing, restart the reader and game;
in Arcadelux, verify the introduction and repeated Up/Down menu announcements,
including switching away and back. Also check existing NVDA/Tolk speech and
ordinary Wine menus and Edit controls before submitting the change.

## Reader reply stalls

Run sequentially on a private X display:

```sh
xvfb-run -a python3 tests/reader_stall_integration.py --build-dir build
xvfb-run -a python3 tests/reader_stall_integration.py --build-dir build --32-bit
xvfb-run -a python3 tests/reader_stall_integration.py --build-dir build --timeout
xvfb-run -a python3 tests/reader_stall_integration.py --build-dir build --focus-error
```

The recording reader delays an editor focus reply for 350 ms while its Wine
control types `abbacdef`. All eight actions, including repeated letters, must
arrive in order with focus established first, and native text and caret must
remain correct. `--timeout` extends the delay past the helper's D-Bus deadline;
`--focus-error` rejects the initial focus exchange and requires recovery before
later text. A second withheld reply checks normal helper shutdown. The fixture
waits for editor-hook attachment before typing, including the 32-bit host.

The original synchronous helper dropped six of the eight characters during
the delayed-reply check. These private recordings establish that shared failure
path; they do not establish the cause of every live MUSHclient speech pause.
After installing the helper and restarting it, check command typing, incoming
plugin speech, output-buffer arrows, menus, return from Linux applications and
reader restart in MUSHclient. Check ordinary Notepad editing and password
exclusion too. Audible speech and physical braille need separate live checks.

## MSAA event stalls

Run sequentially on a private X display, for example with `xvfb-run -a`:

```sh
python3 tests/event_stall_integration.py --build-dir build
python3 tests/event_stall_integration.py --build-dir build --32-bit
python3 tests/event_stall_integration.py --build-dir build --getter
python3 tests/event_stall_integration.py --build-dir build --background
python3 tests/event_stall_integration.py --build-dir build --popup
```

The fixture needs the matching MinGW C++ compiler. It uses a disposable prefix
and recording reader service. It stalls either `WM_GETOBJECT` or MSAA
text-property retrieval for eight seconds. A separate foreground
application must deliver both repeated typed characters and native button
feedback before that stall ends, preserving native text, caret and selection.
The old focus must not surface afterward. A second stall checks normal
`WM_QUIT` shutdown before the provider completes. Background focus events must
neither query unrelated providers nor invalidate foreground feedback, and an
owned nonactivating accessible popup must retain reading without moving native
focus. Use `--reader orca` to check the alternate recording endpoint.

On October 12 the supplied Cthulhu log showed successful reader D-Bus calls,
continued Xorg input and clean reader shutdown; it did not establish a reader
crash. Source inspection found synchronous MSAA calls on the helper event
thread. The original helper failed the blocked-provider typing check; the same
editor fixture without a blocked provider passed. These synthetic checks
establish the shared hang path, not the exact cause of every live MUSHclient
failure. Recheck MUSHclient command typing, incoming plugin output, menus,
plugin output-buffer arrows and keypad review after installing the helper and
restarting the reader. Listen to speech and check physical braille separately.


## Reader endpoint selection

After building, run these checks sequentially on private displays:

```sh
xvfb-run -a python3 tests/controller_integration.py --build-dir build
xvfb-run -a python3 tests/controller_integration.py --build-dir build --reader orca
xvfb-run -a python3 tests/menu_integration.py --build-dir build --reader orca
xvfb-run -a python3 tests/menu_integration.py --build-dir build --reader orca --fixture edit
xvfb-run -a python3 tests/review_integration.py --build-dir build --reader orca
```

The controller test drives the helper through a native Windows NVDA RPC client.
It verifies speech, cancellation, braille, SSML status forwarding, reader loss,
invalid reader values, and startup refusal when only the unselected service
exists. Both service names are owned while the selected reader handles requests.
It also rejects invalid endpoint overrides, missing objects/interfaces,
missing required methods and incorrect input/output signatures.
UIA speech and cancellation methods are checked even with the RPC controller
disabled; missing methods and incompatible input/output signatures must fail startup.
The menu/editor and review tests also accept `--reader cthulhu`; omit the option
to check existing default behavior. Review checks reject callers even when they
own the unselected service, then replace the selected service owner and verify
registration and capture access move to the new owner. Its provider object path
and interface remain the same for both readers.

To check an Orca extension endpoint, add `--extension-endpoint`:

```sh
xvfb-run -a python3 tests/controller_integration.py --build-dir build --reader orca --extension-endpoint
xvfb-run -a python3 tests/menu_integration.py --build-dir build --reader orca --extension-endpoint
xvfb-run -a python3 tests/menu_integration.py --build-dir build --reader orca --extension-endpoint --fixture edit
xvfb-run -a python3 tests/review_integration.py --build-dir build --reader orca --extension-endpoint
```

These publish `/org/gnome/Orca1/Service/WineAccess` with interface
`org.gnome.Orca1.WineAccess`, while retaining the `org.gnome.Orca1.Service`
bus name. Controller checks put overrides before reader selection; control
and review checks put them after it. Review checks still reject unrelated
callers and transfer capture access only when the selected bus owner changes.

These tests supply recording services implementing the Wine protocol; they do
not run Orca or prove audible speech or physical braille. Stock Orca still needs
the reader-side methods and helper lifecycle described in the
[integration contract](../README.md#reader-selection-and-orca-integration).
Before submitting, check Cthulhu's ordinary Wine menus, editor arrows, repeated
characters, selections, deletion, protected fields and keypad review with live
speech and braille. When an Orca integration exists, repeat those workflows
with `--reader orca`, including return to Linux controls and reader restart.

## List-box navigation

For list-box navigation, run these checks sequentially:

```sh
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture listbox
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture listbox --32-bit
```

They cover native Up/Down navigation, Unicode text, positions, focus return,
duplicate suppression, background changes and an emptied list. After installing
the helper and restarting the reader, open AudioQuake's LDL tutorial/example map
chooser and use Up/Down without leaving the list. Check that speech and braille
follow each map and position, then Tab to OK/Cancel and Shift+Tab back. Recheck
combo-box arrows, ordinary list views, tabs/trees and return from Wine menus.
Recorded events alone do not establish audible speech or physical braille.

## Virtual desktop focus recovery

`xvfb-run -a ctest --test-dir build -R foreground-focus --output-on-failure`
uses a disposable Wine prefix configured for a virtual desktop and a separate
Windows launcher fixture. It reproduces a visible launcher returned without
activation, then checks recovery of its native foreground and button focus.
It also checks Linux focus, mismatched window-manager/keyboard focus, disabled
windows, multiple visible applications, hidden windows, existing foreground,
and repeated recovery. It also reproduces X11 focus on the launcher child
with no Win32 foreground, as seen after AudioQuake exits. Recovery must restore
both Win32 activation/control focus and native keyboard focus, even when X11
already selects that child. The fixture deliberately leaves `WM_STATE` unset,
matching Wine's real virtual-desktop children. Adding a synthetic window-manager
acknowledgement masks the failure: native `WM_TAKE_FOCUS` alone can otherwise be
ignored while Wine awaits that state change. The runner propagates the fixture's
actual exit status.

Recovery queues `SetWindowPos` activation on the application's own window
thread and sets native X11 focus without changing its size or position. It
does not wait on the application's window procedure. A dispatched request
alone is not acceptance: the fixture then checks Win32 foreground and the
restored button focus after the application processes activation.

After installing the updated helper and restarting the reader, open AudioQuake,
play and close a game, then Tab and Shift+Tab through the launcher. Check speech
and braille for each control. Switch to Linux and back to workspace 3 and repeat.
Recheck ordinary Wine menus, edits and lists, including password exclusion.
With two visible applications in one virtual desktop, recovery intentionally
does not choose between them; focus the intended application normally.
Automated focus checks do not prove audible speech or physical braille.

## Wine flat-review capture

Build the helper and run `ctest --test-dir build --output-on-failure` on a
private display. The review fixture covers both architectures: visible Edit
text, Unicode offsets before the viewport, wrapping/blank lines, an empty
focus anchor, hidden/password exclusion, password transitions before copying,
clipping, same-length Edit/ListBox/ListView races, native ListView cells,
negative coordinates, source limits and unchanged focus/selection.
It also covers output serviced by a 16 ms message loop, late scalar replies,
nested native containers, deeply clipped text, and maximized versus side-by-side
MDI documents. Covered documents are excluded while visible titles remain
available. These checks reproduce capture failures that can make review report
that it cannot find the current location despite valid Wine focus.
The padded MSAA status-name case checks that text after its terminating NUL
does not reach D-Bus and that range lengths match the text actually sent.
A local provider also checks that malformed UTF-16 padding cannot hide the
valid label.

Run `python3 tests/review_integration.py --build-dir build` and its `--32-bit`
variant sequentially. These exercise the exact wire types, actual-owner
authorization, deadline/busy behavior, blocked-provider focus feedback,
shutdown and older-reader compatibility. The matching reader's
`tests/wine_review_x11.py` drives physical XTest keycodes through its real
command router, D-Bus registry and speech/braille queues. Run its Go test with
`CTHULHU_WINE_REVIEW_BUILD=/absolute/build` and
`go test ./internal/app -run NativeWineReviewPhysicalKeys -count=1 -v` on a
private session/display; add `CTHULHU_WINE_REVIEW_32=1` for a 32-bit application.

Recorded output proves queued text and input consumption, not audible speech
or physical braille. In MUSHclient, focus the plugin's output text window and
check current/previous/next line, words, characters, spelling/phonetics and
window boundaries. Confirm review does not move the native caret; then confirm
ordinary arrows and newly arriving game output still work. Check plugin
dialogs and return to Linux/Fenrir. Custom painted output needs the output
plugin; this protocol supplies no native braille routing or Say All.

Build the project, then run `python3 tests/menu_integration.py --build-dir build`
from the repository root in a graphical session. Dependencies are Wine,
MinGW's x86_64 and i686 C compilers, PyGObject, and `dbus-run-session`.

The test creates a temporary Wine prefix and a private D-Bus service. Its
64-bit PE application exercises the separately running Winelib helper's
global menu hook, rather than calling helper functions inside the fixture.
The test processes carry the managed-helper marker so the running Cthulhu
supervisor does not start an additional helper in the test prefix.

Checks include actual keyboard navigation through File/Edit menus, a nested
submenu and a context menu; displayed command shortcuts; checked and disabled
items; escaped ampersands; duplicate menu selections and reopening; restored
button focus; and exiting with both reader capabilities disabled. Additional
`WM_MENUSELECT` messages exercise duplicate notifications deterministically.

The menu fixture also returns an application-owned MSAA object through
`WM_GETOBJECT`/`LresultFromObject`. The separate helper must retrieve its
`client` role through COM; native text fallback cannot satisfy the check.
This catches missing COM initialization that ordinary Wine control proxies
and the native menu hook did not expose.

The fixture window takes focus and closes automatically. Cleanup stops only
the Wine server for the temporary prefix. The recorded events never reach the
running reader's speech or braille service.

For live acceptance, rebuild/install the package and restart Cthulhu so it
launches the updated helper. In a 64-bit Wine application, use Alt to reach
File/Edit, arrows to move through commands and submenus, Escape to return, and
Shift+F10 for a context menu where supported. Verify speech and braille contain
the highlighted label, role, displayed shortcut, and checked/unavailable state,
and that normal control reading resumes afterward. Test multiple Wine prefixes
and reader shutdown separately. Automated event recording does not establish
live listening or physical braille acceptance.

Entirely custom menus without `WM_MENUSELECT` and full object review are outside
the current implementation.

## BARD Express managed menus

The October 10 investigation found two independent blockers. The helper's
message-loop thread did not initialize COM, so application-owned MSAA queries
failed with `CO_E_NOTINITIALIZED` and used native window text such as `MenuBar`.
The helper now initializes a single-threaded COM apartment before registering
callbacks and uninitializes it after removing them. The new marshaled-provider
check passes with the fix and fails with the previous helper.

BARD's prefix also registered `IAccessible` against UIA type library
`{930299CE-9965-4DEC-B0F4-A54848D4B667}`, version `1.0`, while its installed
`uiautomationcore.dll` lacked the registered resource `3`.
An initialized read-only query failed with `TYPE_E_CANTLOADLIBRARY`.
After backing up the prefix registry, the 32-bit and 64-bit
`HKLM\Software\Classes\Interface\{618736E0-3C3D-11CF-810C-00AA00389B71}\TypeLib`
registrations were pointed to the loadable standard accessibility type library
`{1EA4DBF0-3C3B-11CF-810C-00AA00389B71}`, version `1.1`.
Read-only inspection then retrieved Account/View/Help and their command labels,
shortcuts and unavailable states from the open application. This repair is
specific to a verified prefix mismatch; the helper does not change registries.

After installing the helper, restart Cthulhu to load it. In BARD, press Alt,
move Left/Right among Account, View and Help, then Down/Up among commands.
Check unavailable items while working offline and Escape back to the main
screen. Recheck Tab/Shift+Tab through buttons, preferences and login fields,
including password exclusion, and ordinary Wine Notepad menus/editing.
Verify audible speech and physical braille separately; querying menu labels
alone does not establish either output gate.

## Editor and actual Notepad checks

The CMake build also includes a small MSAA state decoder check. Run it with
`xvfb-run -a ctest --test-dir build --output-on-failure`. It uses its own prefix
under the build directory, marks it as a managed test process and never sends
reader output. It verifies combined bitmasks, unchecked radio buttons, mixed
checkboxes, focus-only state suppression and password flags. It does not
establish that a particular application's MSAA provider emits those states.

Run these against the built helper, optionally prefixed with `xvfb-run -a` for
a private X display:

```sh
python3 tests/menu_integration.py --build-dir build --fixture edit
python3 tests/menu_integration.py --build-dir build --fixture edit --late-helper
python3 tests/menu_integration.py --build-dir build --fixture edit --restart-helper
python3 tests/menu_integration.py --build-dir build --fixture edit --32-bit
python3 tests/menu_integration.py --build-dir build --fixture edit --32-bit --late-helper
python3 tests/menu_integration.py --build-dir build --fixture edit --32-bit --restart-helper
python3 tests/menu_integration.py --build-dir build --fixture winforms --32-bit
python3 tests/menu_integration.py --build-dir build --fixture notepad
```

The standard Edit fixture checks focus, typing echo, characters/words/lines,
incremental selection and unselection, Backspace/Delete/Clear, read-only controls, password
exclusion, surrogate pairs, rapid repeated letters, menu return at the caret,
short replacements, CRLF deletion, long-line truncation, Undo snapshots, and
Ctrl+End line reading, and Up/Down navigation in a read-only multiline output
control. Typing checks include repeated letters, spaces, Enter/Tab, accented
characters, surrogate pairs, selection replacement, documents beyond the full
snapshot limit, and silence for password/background/read-only fields and
input rejected at the text limit. Command-history checks consume queued Up/Down
before dispatch, then replace the text and move the caret as MUSHclient does.
They require ordered, single announcements for equal-length and rapid recalls
and empty input, with no password, background or unrelated programmatic output.
An unchanged history boundary is followed by a worker-thread text replacement
before another queued message is removed. That replacement must stay silent,
and subsequent navigation must read from the updated text snapshot.
Both 32-bit and 64-bit fixtures use the same assertions. Lifecycle variants
attach after the control has focus or restart the helper without closing it.
Every text action must have an established
focus source, matching the Go reader's filtering contract.

The Notepad fixture launches Wine's actual `notepad.exe` and uses `SendInput`
for typing, arrows, Ctrl+Right, Shift selection, Delete, and Alt/Escape menu return.
It checks resulting document text as well as recorded accessibility output. These
tests use a recording D-Bus service; they do not run the full reader or prove
audible typing echo, physical keys, or a physical braille display.

For live MUSHclient acceptance, install the helper, restart Cthulhu and reopen
MUSHclient so the updated 32-bit DLL can load. In the command field, check Left/Right and
Ctrl+Left/Right feedback without submitting a command. Use Up/Down to recall
existing command history. Check each recalled command is spoken once,
including equal-length entries and `blank` when returning to empty input.
Do not submit recalled commands just to test speech.
Use Ctrl+Tab to reach the read-only output notepad supplied by the Aardwolf
review-buffer plugin; check Up/Down line reading and Left/Right characters
there, then return to the command field. Check plugin menus and dialogs still
work, and repeat after restarting the reader. These hooks provide caret feedback; independent review
commands use the optional flat-review protocol described above. Native braille
routing into Wine text remains unsupported.

The earlier 2026-10-10 helper fixtures and Go package tests did not establish
that Go accepted editor `text` events. The reader follow-up adds that support,
focused name/state handling, repeated-action and password/focus tests, and a
real private-session D-Bus test through the Go presenter. See the sibling
reader's `docs/testing/wine-accessibility.md` for current evidence and live
acceptance gates. Run Xvfb fixtures sequentially; concurrent automatic display
allocation can collide.

## GoldWave menus and combo boxes

The helper supplies both 32-bit and 64-bit menu hooks. Check both architectures:

```sh
xvfb-run -a python3 tests/menu_integration.py --fixture menu
xvfb-run -a python3 tests/menu_integration.py --fixture menu --32-bit
xvfb-run -a python3 tests/menu_integration.py --fixture controls
xvfb-run -a python3 tests/menu_integration.py --fixture controls --32-bit
xvfb-run -a python3 tests/menu_integration.py --fixture goldwave --goldwave-exe /path/to/GoldWave.exe
```

The controls fixture changes a combo selection without emitting a value
WinEvent. It requires the new value while focus stays on the combo, with the
same source identity as its focus event. This catches both missing polling and
Wine's misleading focus notifications for the combo's internal list.

The optional GoldWave 5.70 fixture copies the application directory into a
temporary directory and uses a fresh Wine prefix with Force screen reader
mode enabled. It waits for the actual main form, dismisses the first-run
settings prompt in the test copy, and drives Alt+F, menu arrows, Ctrl+O and
file-type combo Down/Down/Up using SendInput. On October 11 it received File,
New, Open and unavailable Close menu events, followed by Wave/MPEG Audio/Wave
value updates without tabbing away. This confirms helper events through the
private D-Bus recorder; audible speech and physical braille need live checks.

Install all five helper artifacts together, restart Cthulhu, and reopen
GoldWave. With screen reader mode enabled, check File and other menus with
Alt and arrows, then Escape back to the previous control. In Open Sound,
check Files of type and Look in with arrows: expect the new value immediately
in speech and braille, with keyboard focus remaining on the combo. Repeat
Tab/Shift+Tab and Alt+Down/Escape dropdown opening and closing.

## Notepad++ / Scintilla checks

Use a locally available 64-bit Notepad++ executable:

```sh
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture scintilla --notepadpp-exe /path/to/notepad++.exe
```

The runner copies the executable and model XML files into a temporary directory,
uses local configuration, disables plugins/session restoration, and opens a
disposable UTF-8 document in its private Wine prefix. The user's running
Notepad++ and documents are untouched. The fixture uses actual `SendInput`
arrows, Ctrl+Right, Shift selection, Delete, Backspace, undo and menu return;
checks Ctrl+X, multibyte accented characters, emoji, a document over one million
bytes and truncation at a surrogate pair; and verifies document length
after a read-only deletion attempt. Add `--late-helper` or `--restart-helper`
to check attachment and reader restart while the editor stays open.

After installing, restart Cthulhu and close/reopen Notepad++ so its process
loads the new DLL. In a disposable document with several lines, accented
characters and emoji, check Up/Down line reading and Left/Right character
reading in both directions. Check Ctrl+Left/Right words, Shift selection and
unselection, Backspace/Delete, undo, Alt/Escape return and switching document
tabs. Repeat ordinary Wine Notepad editing, menu navigation, and password
fields in other applications for regressions. Check speech and physical
braille separately. These recorder tests do not establish either live output.

## List-view checks

```sh
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture list
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture list --32-bit
```

The second command requires `i686-w64-mingw32-gcc`. Both use a private prefix
and recording D-Bus service. They verify first-row reading without selecting
it, two columns, Unicode and literal ampersands, Down/Up, button/list focus
return, changed row text on a value event, and deletion of all rows without
stale output. Run them sequentially. Both architecture fixtures passed on
October 10, as did the existing menu, editor, actual Notepad and CTest MSAA
state checks. The reader's focused Wine race checks also passed.

The BARD Express bootstrapper was inspected in place on October 10. Its
32-bit `SysListView32` has one row: `Pending, Microsoft .NET Framework 4.7.2 Full`.
The new query code retrieved that row without changing the installer. This
does not establish audible output or successful prerequisite installation.

After installing the helper and restarting Cthulhu, Tab to the prerequisite
list: expect the instructions, list role, pending component and `1 of 1`.
Check arrows and Tab/Shift+Tab back to Install/Cancel. Also check a multirow
native list, normal menus, editor navigation, switching to a native Linux
application, and reader shutdown. Verify speech and physical braille separately.

## Delphi Setup lists and checkboxes

The October 10 GoldWave 5.70 Setup inspection found a 32-bit `TListView`
with 14 checkbox rows, plus `TButton` and `TBitBtn` controls. Wine exposed
them as generic MSAA clients; the list client's name/value were empty. Focus
events were present for the buttons and on return to the list. The native
messages already exposed the option captions and checkbox state, but the
helper did not recognize these VCL class names or read list checkbox states.

The explicit VCL aliases and native checkbox query fix those shared gaps.
The updated query code read the actual open Setup's first option, `Disable
effect plug-ins`, `not checked`, position 1 of 14, and the Backup/Restore/OK/
Cancel button roles without changing settings or sending speech. A later
live registry query also confirmed `StartupOptions=0x3008` and Setup showed
`Force screen reader mode` checked; the earlier immediate persistence query
had still seen `0x1008`.

```sh
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture delphi --32-bit
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture delphi
```

Both fixtures passed with native controls registered under VCL names. They
check initial rows/labels, Down navigation, Space check/uncheck without
synthetic accessibility events, button roles, return to the checked row,
and empty-list state reset. The existing 32-bit plain-list regression also
passed. These are private D-Bus recordings; audible GoldWave speech and
physical braille remain a live acceptance check after installing the helper
and restarting Cthulhu. List queries are independent of the menu/editor hooks.

## Native tabs, trees and named clients

```sh
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture controls
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture controls --32-bit
```

These private fixtures exercise native and `ATL:SysTabControl32` tab captions,
positions and arrow navigation, tree selection/expansion/navigation and focus
return, named native buttons exposed as generic MSAA clients, and combo boxes
with labels created after their fields. The 64-bit fixture also checks the
editor hook's late native label. Empty tabs/trees must drop their previous
caption. The existing menu, editor, Notepad, list and managed-field fixtures
remain regression checks; an application-owned MSAA provider in the menu
fixture must retain its role instead of being replaced by native queries.

The controls fixture also verifies literal ampersands in combo-box, edit and
list-box values and window titles, escaped ampersands in button/label captions,
and literal `SS_NOPREFIX` labels. Both control architectures exercise the
shared remote allocation used by native tabs and trees; the list fixtures
exercise the same allocation for multi-column rows.

Read-only inspection of foobar2000 v2.26.1 with the new native query code
retrieved `All Music`, `Album List`, and `Default Playlist` from the open
application. This identifies data missed by the old helper; it does not prove
live speech, physical braille, or complete foobar2000 support. Its custom
playlist MSAA provider is separate from native tabs and trees.

After rebuilding/installing all three helper files, restart the reader and
reopen foobar2000 after saving work. Tab and Shift+Tab through the album tree,
View combo box, Filter edit, album/property tabs and playlist tabs. Expect
captions plus their roles; arrows should read the new selected tab/tree node,
with expanded/collapsed states where appropriate. Check native buttons,
combo-box value changes, custom playlist item reading, Alt menus and Escape
return, ordinary Notepad editing, password exclusion, and switching back to a
native Linux application. Verify speech and physical braille separately.

## Windows Forms login fields

```sh
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture winforms
xvfb-run -a python3 tests/menu_integration.py --build-dir build --fixture winforms --late-helper
```

This reuses the editing workflow with native controls registered under
Windows Forms class names and labels created after the fields. It verifies
`Email, edit` focus, `Password, edit, password` with no protected value,
navigation/selection/deletion and unrelated-label exclusion. It does not run
the .NET framework itself or establish live BARD speech/braille acceptance.
The ordinary and late-helper managed fixtures passed on October 10, together
with the existing native editor, Notepad, menu and 32/64-bit list regressions.

Read-only inspection of the BARD login on October 10 confirmed a 64-bit
Windows Forms application with `WindowsForms10.EDIT.app.*` email/password
controls, adjacent visible `Email:`/`Password:` labels, and the `ES_PASSWORD`
style on the password field. Its MSAA objects were unavailable to the probe;
the previous exact `Edit` class checks missed both fields. The helper now
recognizes the managed native-control class names in its standard reader and
editor hook. Existing native controls keep their original label lookup.

After installing the updated package, close BARD and restart Cthulhu so its
helper and the application load the new DLL together. Reopen BARD in its own
prefix. Tab and Shift+Tab between Email, Password, Sign in and Work Offline.
Expect labels and edit/password roles; navigate and select ordinary email
text, and confirm password contents stay excluded. Recheck native Notepad,
menus, the installer list and switching to Linux applications. Standard Edit
typing echo is now forwarded through editor events; routable Wine review
remains unfinished.

## Live Notepad acceptance

Install all three helper files together and use the matching Cthulhu source.
Close existing Notepad windows after saving any work so the updated hook can load.

1. Quit Cthulhu with Cthulhu+Q.
2. Press Ctrl+Escape, then Shift+G. These are separate key presses. Shift+G
   rebuilds Cthulhu and its braille helper and opens the test terminal; it does
   not build wine-access.
3. Run `wine notepad` in the intended Wine prefix. Expect edit/blank focus
   feedback. Type `hello beta`, Enter, then `second line`. Expect each typed
   character, including both `l` characters, spaces and the line break. Standard
   Edit typing uses the reader's editor feedback path. Check typing over selected
   text too, and confirm password fields never announce their typed contents.
   Type `AaÉé`: capitals should use Cthulhu's uppercase pitch, with normal pitch
   restored for each lowercase letter. Repeat with a custom character echo voice
   if configured, and confirm braille preserves the original case.
4. Press Ctrl+Home, then Right three times. Expect the first line at Ctrl+Home,
   then `e`, `l`, `l`. Both repeated letters should produce feedback. Ctrl+Right
   should read `beta`; Down should read `second line`.
5. Press Home, Shift+Right twice, then Shift+Left twice. Expect `s selected`,
   `e selected`, `e unselected`, `s unselected`. Focus stays in the edit area.
   Delete should say `s deleted`. Right followed by Backspace should say
   `e`; the second line is now `cond line`.
6. Press Alt to enter the menus and Escape to return (Escape again if needed).
   Expect menu labels while navigating and `edit, cond line` on return, not
   the start of the document. Arrows must continue to reach Notepad.
7. Use Undo, then navigate the restored text. Expect feedback to match the
   document. Switch to another application and back; verify focus and keyboard
   reading resume normally. Close Notepad without saving this test document.

Connected braille should show the corresponding feedback messages. This does
not establish a routable editor buffer. Report the step, exact speech and
braille, focused control, and any key that behaved differently. For unexpected
results inspect `~/devel/cthulhu.log`; debug `Wine editor feedback` records
include source IDs, native UTF-16 selection ranges, action kinds and output text.

The Notepad fixture also opens the unsaved-document dialog and presses Tab,
Tab, Shift+Tab and Escape. It records the actual Yes/No/Cancel focus and state
sequence. Wine sends a focus-loss state event for the previous button before
the new focus event; the Go presenter must suppress that unchanged state
presentation. For live acceptance, change the document, close Notepad and
verify each Tab announces only the newly focused button, including reverse
navigation. Escape must return to the editor without discarding the document.

## Helper identity and startup diagnostics

```sh
python3 tests/version_metadata_test.py
xvfb-run -a python3 tests/diagnostics_test.py --build-dir build
```

The metadata check uses a temporary Git repository and a source archive to
verify clean/modified builds, version edits, commit changes and unchanged
header timestamps. The Wine check uses a private D-Bus service, display and
prefix. It queries `--version` without a reader and while the singleton is
held, verifies identity on failed reader discovery, and checks normal and
missing-hook initialization records. It never contacts the active reader.

After installing both updates and restarting Cthulhu, launch AudioQuake and
check its log for `Wine accessibility helper identity` and
`Wine accessibility helper initialized`, with the expected version/revision.
Enable debug logging to confirm the executable, loader and prefix selected.
Check the launcher list with Down/Down/Up and Tab/Shift+Tab, its map chooser,
and returning to the launcher after game exit. Recheck ordinary Wine Notepad
typing, arrow navigation, menus and shutdown, including password exclusion.
Audible speech and physical Braille require separate live checks. This change
adds diagnostics; it does not establish a fix for a remote machine's silence.