wine-access/tests/README.md

# Wine control integration

## 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.
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.

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. The fixture acknowledges ICCCM window visibility on
the private display; the runner propagates the fixture's actual exit status.

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.
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-Go 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-go.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.