432 lines
16 KiB
Go
432 lines
16 KiB
Go
// 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 TestDocumentSoundGeometryHonorsCaptureGateAndCancellation(t *testing.T) {
|
|
adapter := New()
|
|
tree := testTree(t)
|
|
object, _ := tree.Reference(testID("/first"))
|
|
adapter.SetCaptureSoundGeometry(false)
|
|
geometry, err := adapter.CaptureDocumentSoundGeometry(context.Background(), object, ObjectReference{})
|
|
if err != nil || geometry != [2]SoundGeometry{} {
|
|
t.Fatalf("disabled sound geometry accessed the stopped adapter: %+v, %v", geometry, err)
|
|
}
|
|
adapter.SetCaptureSoundGeometry(true)
|
|
canceled, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
if _, err := adapter.CaptureDocumentSoundGeometry(canceled, object, ObjectReference{}); !errors.Is(err, context.Canceled) {
|
|
t.Fatalf("canceled geometry capture error = %v", err)
|
|
}
|
|
adapter.documentTree = tree
|
|
tree.Invalidate(object.ID())
|
|
if _, err := adapter.captureNativeDocumentSoundGeometry(context.Background(), [2]ObjectReference{object}); !errors.Is(err, ErrStaleObject) {
|
|
t.Fatalf("stale geometry reference accepted: %v", err)
|
|
}
|
|
}
|
|
|
|
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")
|
|
}
|
|
}
|