Cthulhu is no longer a fork. Now it is a screen reader written in Golang.
This commit is contained in:
Storm Dragon committed
1 parent
a998fe67de
commit
069fc674dc
708 files changed
+112482
-532
No files matched your search
@@ -0,0 +1,409 @@
|
||||
// Cthulhu screen reader.
|
||||
// Copyright (c) 2026 Storm Dragon
|
||||
// Authors: Storm Dragon, Angus Kola
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify it
|
||||
// under the terms of the GNU General Public License as published by the Free
|
||||
// Software Foundation, either version 3 of the License, or (at your option)
|
||||
// any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
// more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License along with
|
||||
// this program. If not, see <https://www.gnu.org/licenses/gpl-3.0.html>.
|
||||
|
||||
package atspi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestAdmitNativeChildKeepsFirstTreeEdge(t *testing.T) {
|
||||
child := NewObjectID(":1.42", "/child")
|
||||
scheduled := make(map[ObjectID]struct{})
|
||||
if !admitNativeChild(scheduled, child) {
|
||||
t.Fatal("first child edge was rejected")
|
||||
}
|
||||
if admitNativeChild(scheduled, child) {
|
||||
t.Fatal("duplicate child edge was accepted")
|
||||
}
|
||||
if len(scheduled) != 1 {
|
||||
t.Fatalf("scheduled children = %d, want 1", len(scheduled))
|
||||
}
|
||||
}
|
||||
|
||||
func TestDocumentCompletionRetainsNativeFocusWithoutChromeFocus(t *testing.T) {
|
||||
chrome := NewObjectID(":1.42", "/address")
|
||||
for _, eventType := range []string{DocumentLoadCompleteEvent, DocumentLoadStoppedEvent, BusyStateEvent} {
|
||||
t.Run(eventType, func(t *testing.T) {
|
||||
if !shouldRetainNativeFocus(eventType, 0, ObjectID{}) {
|
||||
t.Fatal("completion cannot resolve its document without a retained native source")
|
||||
}
|
||||
if shouldRetainNativeFocus(eventType, 0, chrome) {
|
||||
t.Fatal("background completion displaced retained chrome focus")
|
||||
}
|
||||
})
|
||||
}
|
||||
for _, eventType := range []string{DocumentReloadEvent, BusyStateEvent} {
|
||||
if shouldRetainNativeFocus(eventType, 1, ObjectID{}) {
|
||||
t.Fatalf("loading start %q acquired document focus", eventType)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestDetachedDocumentWindowRequiresSelectedOwnedTab(t *testing.T) {
|
||||
document := NewObjectID(":1.42", "/old_document")
|
||||
window := NewObjectID(":1.42", "/browser_window")
|
||||
other := NewObjectID(":1.42", "/other_window")
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
active, selected, known ObjectID
|
||||
eventType string
|
||||
detail int
|
||||
want bool
|
||||
}{
|
||||
{"returned selected tab", ObjectID{}, window, window, FocusedStateEvent, 1, true},
|
||||
{"other window selected", ObjectID{}, other, window, FocusedStateEvent, 1, false},
|
||||
{"background focus loss", ObjectID{}, window, window, FocusedStateEvent, 0, false},
|
||||
{"active focus loss", document, ObjectID{}, window, FocusedStateEvent, 0, false},
|
||||
{"background caret", ObjectID{}, window, window, CaretEvent, 1, false},
|
||||
{"established document caret", document, ObjectID{}, window, CaretEvent, 1, true},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
if got := restoredDocumentWindowAllowed(document, tc.active, tc.selected, tc.known, tc.eventType, tc.detail); got != tc.want {
|
||||
t.Fatalf("window restoration = %t, want %t", got, tc.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCaptureDesktopRejectsUnavailableAdapterAndCanceledContext(t *testing.T) {
|
||||
adapter := New()
|
||||
if _, err := adapter.CaptureDesktop(context.Background()); err == nil {
|
||||
t.Fatal("capture succeeded before adapter start")
|
||||
}
|
||||
canceled, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
if _, err := adapter.CaptureDesktop(canceled); !errors.Is(err, context.Canceled) {
|
||||
t.Fatalf("canceled capture error = %v", err)
|
||||
}
|
||||
if _, err := adapter.CaptureDesktop(nil); err == nil {
|
||||
t.Fatal("capture accepted a nil context")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDocumentCaptureTreeIsIndependentAndInvalidated(t *testing.T) {
|
||||
for _, eventType := range []string{ChildrenAddedEvent, DefunctStateEvent, DocumentReloadEvent, "shutdown"} {
|
||||
t.Run(eventType, func(t *testing.T) {
|
||||
adapter := New()
|
||||
adapter.tree = testTree(t)
|
||||
adapter.documentTree = testTree(t)
|
||||
root, _ := adapter.tree.Root()
|
||||
reviewRef, _ := adapter.tree.Reference(testID("/first"))
|
||||
documentRef, _ := adapter.documentTree.Reference(testID("/first"))
|
||||
if eventType == "shutdown" {
|
||||
adapter.invalidateTree()
|
||||
} else {
|
||||
adapter.invalidateTreeEvent(eventType, 1, root.ID(), ObjectID{})
|
||||
}
|
||||
if _, err := adapter.tree.Resolve(reviewRef); !errors.Is(err, ErrStaleObject) {
|
||||
t.Fatalf("review reference survived %s: %v", eventType, err)
|
||||
}
|
||||
if eventType == ChildrenAddedEvent {
|
||||
if _, err := adapter.documentTree.Resolve(documentRef); err != nil {
|
||||
t.Fatalf("insertion retired surviving document child: %v", err)
|
||||
}
|
||||
documentRoot, _ := adapter.documentTree.Root()
|
||||
if _, _, err := adapter.documentTree.FirstChild(documentRoot); !errors.Is(err, ErrIncompleteTree) {
|
||||
t.Fatalf("insertion left old child order navigable: %v", err)
|
||||
}
|
||||
} else if _, err := adapter.documentTree.Resolve(documentRef); !errors.Is(err, ErrStaleObject) {
|
||||
t.Fatalf("document reference survived %s: %v", eventType, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
adapter := New()
|
||||
adapter.tree = testTree(t)
|
||||
root, _ := adapter.tree.Root()
|
||||
reviewRef, _ := adapter.tree.Reference(testID("/first"))
|
||||
snapshot := NewSnapshot(root.ID().Path, "Document", "document web", "", "")
|
||||
snapshot.BusName = root.ID().BusName
|
||||
document, err := adapter.installCapturedTree(root.ID(), []TreeNode{{Snapshot: snapshot}}, true, false)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if document == adapter.tree {
|
||||
t.Fatal("document capture replaced review tree")
|
||||
}
|
||||
if _, err := adapter.tree.Resolve(reviewRef); err != nil {
|
||||
t.Fatalf("document capture invalidated independent review position: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReplacementDocumentRetiresOnlyActiveApplicationTree(t *testing.T) {
|
||||
adapter := New()
|
||||
adapter.documentTree = testTree(t)
|
||||
old, err := adapter.documentTree.Reference(testID("/first"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
replacement := testID("/replacement")
|
||||
adapter.invalidateTreeEvent(DocumentLoadCompleteEvent, 0, replacement, ObjectID{})
|
||||
if _, err := adapter.documentTree.Resolve(old); err != nil {
|
||||
t.Fatalf("unknown load source unexpectedly retired tree: %v", err)
|
||||
}
|
||||
adapter.invalidateReplacedDocument(replacement, testID("/background"))
|
||||
if _, err := adapter.documentTree.Resolve(old); err != nil {
|
||||
t.Fatalf("inactive document retired tree: %v", err)
|
||||
}
|
||||
adapter.invalidateReplacedDocument(replacement, replacement)
|
||||
if _, err := adapter.documentTree.Resolve(old); !errors.Is(err, ErrStaleObject) {
|
||||
t.Fatalf("active replacement left old document available: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDocumentTextTreeTracksLayoutInvalidationIndependently(t *testing.T) {
|
||||
adapter := New()
|
||||
adapter.documentTree = testTree(t)
|
||||
adapter.documentTextTree = testTree(t)
|
||||
semantic, _ := adapter.documentTree.Reference(testID("/first"))
|
||||
visual, _ := adapter.documentTextTree.Reference(testID("/first"))
|
||||
|
||||
adapter.invalidateTreeEvent(BoundsChangedEvent, 0, testID("/first"), ObjectID{})
|
||||
if _, err := adapter.documentTree.Geometry(semantic); err != nil {
|
||||
t.Fatalf("semantic document geometry was invalidated: %v", err)
|
||||
}
|
||||
if _, err := adapter.documentTextTree.Geometry(visual); !errors.Is(err, ErrStaleGeometry) {
|
||||
t.Fatalf("visual document geometry error = %v, want stale geometry", err)
|
||||
}
|
||||
|
||||
adapter.documentTextTree = testTree(t)
|
||||
visual, _ = adapter.documentTextTree.Reference(testID("/first"))
|
||||
adapter.invalidateTreeEvent(CaretEvent, 1, testID("/first"), ObjectID{})
|
||||
if _, err := adapter.documentTextTree.VisibleText(visual); err != nil {
|
||||
t.Fatalf("caret event invalidated reusable visual text: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdapterTreeInvalidationPolicy(t *testing.T) {
|
||||
t.Run("unrelated semantic events preserve document", func(t *testing.T) {
|
||||
for _, eventType := range []string{AccessibleNameEvent, AccessibleValueEvent, ValueChangedEvent, "object:state-changed:selected", "object:state-changed:checked", "object:state-changed:sensitive"} {
|
||||
t.Run(eventType, func(t *testing.T) {
|
||||
adapter := New()
|
||||
adapter.documentTree = testTree(t)
|
||||
cached, _ := adapter.documentTree.Reference(testID("/first"))
|
||||
for _, source := range []ObjectID{testID("/browser-chrome"), {BusName: ":1.999", Path: cached.ID().Path}, {}} {
|
||||
adapter.invalidateTreeEvent(eventType, 1, source, ObjectID{})
|
||||
if _, err := adapter.documentTree.Resolve(cached); err != nil {
|
||||
t.Fatalf("outside event from %v discarded document: %v", source, err)
|
||||
}
|
||||
}
|
||||
if got := adapter.TreeInvalidations(); got != 0 {
|
||||
t.Fatalf("unrelated events invalidated %d objects", got)
|
||||
}
|
||||
adapter.invalidateTreeEvent(eventType, 1, cached.ID(), ObjectID{})
|
||||
if _, err := adapter.documentTree.Resolve(cached); !errors.Is(err, ErrStaleSnapshot) {
|
||||
t.Fatalf("in-document change did not retire snapshot: %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("semantic change preserves identities for refresh", func(t *testing.T) {
|
||||
tree := testTree(t)
|
||||
adapter := New()
|
||||
adapter.documentTree = tree
|
||||
cached, _ := tree.Reference(testID("/first"))
|
||||
adapter.invalidateTreeEvent(AccessibleNameEvent, 0, cached.ID(), ObjectID{})
|
||||
if _, err := tree.Resolve(cached); !errors.Is(err, ErrStaleSnapshot) {
|
||||
t.Fatalf("semantic snapshot error = %v, want stale semantics", err)
|
||||
}
|
||||
root, err := tree.Root()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
current, err := tree.Reference(cached.ID())
|
||||
if err != nil || current != cached {
|
||||
t.Fatalf("name change retired the current identity: %v", err)
|
||||
}
|
||||
cachedNodes := tree.nativeRefresh(root.ID())
|
||||
if len(cachedNodes) == 0 || !cachedNodes[cached.ID()].snapshotInvalid {
|
||||
t.Fatal("semantic refresh omitted the dirty object")
|
||||
}
|
||||
nodes := make([]TreeNode, 0, len(cachedNodes))
|
||||
for id, entry := range cachedNodes {
|
||||
if id == cached.ID() {
|
||||
entry.snapshot.Name = "Updated name"
|
||||
}
|
||||
nodes = append(nodes, TreeNode{Snapshot: entry.snapshot, Children: entry.children, Geometry: entry.geometry, Text: entry.text})
|
||||
}
|
||||
if err := tree.Replace(root.ID(), nodes); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
snapshot, err := tree.Resolve(cached)
|
||||
if err != nil || snapshot.Name != "Updated name" {
|
||||
t.Fatalf("refreshed object = %+v, %v", snapshot, err)
|
||||
}
|
||||
tree.InvalidateSnapshot(cached.ID())
|
||||
tree.MarkChildrenChanged(root.ID())
|
||||
if plan := tree.nativeRefresh(root.ID()); !plan[root.ID()].childrenInvalid || !plan[cached.ID()].snapshotInvalid {
|
||||
t.Fatal("incremental refresh lost a dirty child list or snapshot")
|
||||
}
|
||||
tree.Invalidate(root.ID())
|
||||
if plan := tree.nativeRefresh(root.ID()); plan != nil {
|
||||
t.Fatal("incremental refresh retained a replaced document")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("known removal", func(t *testing.T) {
|
||||
tree := testTree(t)
|
||||
adapter := New()
|
||||
adapter.tree = tree
|
||||
removed, _ := tree.Reference(testID("/second"))
|
||||
kept, _ := tree.Reference(testID("/first"))
|
||||
adapter.invalidateTreeEvent(ChildrenRemovedEvent, 0, testID("/root"), removed.ID())
|
||||
if _, err := tree.Resolve(removed); !errors.Is(err, ErrStaleObject) {
|
||||
t.Fatalf("removed reference error = %v", err)
|
||||
}
|
||||
if _, err := tree.Resolve(kept); err != nil {
|
||||
t.Fatalf("unrelated sibling became stale: %v", err)
|
||||
}
|
||||
if got := adapter.TreeInvalidations(); got != 2 {
|
||||
t.Fatalf("invalidation count = %d, want 2", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("addition invalidates cached children", func(t *testing.T) {
|
||||
tree := testTree(t)
|
||||
adapter := New()
|
||||
adapter.tree = tree
|
||||
root, _ := tree.Root()
|
||||
child, _, _ := tree.FirstChild(root)
|
||||
adapter.invalidateTreeEvent(ChildrenAddedEvent+":system", 1, root.ID(), ObjectID{})
|
||||
if _, err := tree.Resolve(root); err != nil {
|
||||
t.Fatalf("parent became stale: %v", err)
|
||||
}
|
||||
if _, err := tree.Resolve(child); !errors.Is(err, ErrStaleObject) {
|
||||
t.Fatalf("cached child error = %v, want stale object", err)
|
||||
}
|
||||
if got := adapter.TreeInvalidations(); got != 3 {
|
||||
t.Fatalf("invalidation count = %d, want 3", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("defunct false is ignored", func(t *testing.T) {
|
||||
tree := testTree(t)
|
||||
adapter := New()
|
||||
adapter.tree = tree
|
||||
root, _ := tree.Root()
|
||||
adapter.invalidateTreeEvent(DefunctStateEvent, 0, root.ID(), ObjectID{})
|
||||
if _, err := tree.Resolve(root); err != nil {
|
||||
t.Fatalf("false defunct state invalidated root: %v", err)
|
||||
}
|
||||
adapter.invalidateTreeEvent(DefunctStateEvent, 1, root.ID(), ObjectID{})
|
||||
if _, err := tree.Resolve(root); !errors.Is(err, ErrStaleObject) {
|
||||
t.Fatalf("defunct root error = %v, want stale object", err)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("navigation defunct preserves semantic document", func(t *testing.T) {
|
||||
owned := testTree(t)
|
||||
document := testTree(t)
|
||||
visual := testTree(t)
|
||||
adapter := New()
|
||||
adapter.tree = owned
|
||||
adapter.documentTree = document
|
||||
adapter.documentTextTree = visual
|
||||
target := testID("/first")
|
||||
adapter.invalidateTreeEventWithPolicy(DefunctStateEvent, 1, target, ObjectID{}, true)
|
||||
for name, tree := range map[string]*AccessibleTree{"owned": owned, "visual": visual} {
|
||||
if _, err := tree.Reference(target); !errors.Is(err, ErrObjectNotFound) {
|
||||
t.Fatalf("%s target error = %v, want missing", name, err)
|
||||
}
|
||||
}
|
||||
if _, err := document.Reference(target); err != nil {
|
||||
t.Fatalf("semantic document target was invalidated: %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestAdapterInvalidatesGeometryWithoutRemovingObjects(t *testing.T) {
|
||||
for _, eventType := range []string{BoundsChangedEvent, VisibleStateEvent, ShowingStateEvent} {
|
||||
for _, detail := range []int{0, 1} {
|
||||
t.Run(eventType+fmt.Sprint(detail), func(t *testing.T) {
|
||||
tree := testTree(t)
|
||||
adapter := New()
|
||||
adapter.tree = tree
|
||||
second, _ := tree.Reference(testID("/second"))
|
||||
child, _, _ := tree.FirstChild(second)
|
||||
adapter.invalidateTreeEvent(eventType, detail, second.ID(), ObjectID{})
|
||||
for _, ref := range []ObjectReference{second, child} {
|
||||
if _, err := tree.Geometry(ref); !errors.Is(err, ErrStaleGeometry) {
|
||||
t.Fatalf("geometry error = %v", err)
|
||||
}
|
||||
if _, err := tree.Resolve(ref); err != nil {
|
||||
t.Fatalf("object invalidated: %v", err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestQueuedDocumentPositionRejectsDepartedFocus(t *testing.T) {
|
||||
tree, err := NewAccessibleTree(testID("/root"), documentTestNodes())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
position, err := tree.Reference(testID("/heading"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, tc := range []struct {
|
||||
path string
|
||||
allowed bool
|
||||
}{
|
||||
{"/heading", true}, {"/link", true}, {"/chrome", false}, {"/other", false}, {"/gone", false},
|
||||
} {
|
||||
if err := documentPositionMatchesFocus(tree, position, testID(tc.path)); (err == nil) != tc.allowed {
|
||||
t.Fatalf("focus %s: %v", tc.path, err)
|
||||
}
|
||||
}
|
||||
tree.Invalidate(testID("/heading"))
|
||||
if err := documentPositionMatchesFocus(tree, position, testID("/link")); err == nil {
|
||||
t.Fatal("stale target accepted")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSecureInputCancelsCapturesAcrossLockTransitions(t *testing.T) {
|
||||
adapter := New()
|
||||
before, cancelBefore := adapter.secureRequestContext(context.Background())
|
||||
defer cancelBefore()
|
||||
adapter.SetSecureInputActive(true)
|
||||
select {
|
||||
case <-before.Done():
|
||||
case <-time.After(time.Second):
|
||||
t.Fatal("lock did not cancel in-flight capture")
|
||||
}
|
||||
during, cancelDuring := adapter.secureRequestContext(context.Background())
|
||||
defer cancelDuring()
|
||||
if during.Err() == nil {
|
||||
t.Fatal("capture allowed while locked")
|
||||
}
|
||||
adapter.SetSecureInputActive(false)
|
||||
after, cancelAfter := adapter.secureRequestContext(context.Background())
|
||||
defer cancelAfter()
|
||||
if after.Err() != nil {
|
||||
t.Fatal("unlock left captures canceled")
|
||||
}
|
||||
if before.Err() == nil || during.Err() == nil {
|
||||
t.Fatal("unlock revived old capture")
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user