234 lines
8.8 KiB
Go
234 lines
8.8 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 app
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.stormux.org/storm/cthulhu/internal/atspi"
|
|
)
|
|
|
|
func TestTableWindowDescriptionSurvivesImmediateTableFocus(t *testing.T) {
|
|
speech := &fakeSpeechQueue{spoken: make(chan string, 3), requests: make(chan speechRequest, 3)}
|
|
adapter := &fakeAdapter{events: make(chan atspi.Event, 3)}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
completed := make(chan struct{})
|
|
go func() {
|
|
processEvents(ctx, slog.New(slog.DiscardHandler), speech, adapter, 0)
|
|
close(completed)
|
|
}()
|
|
window := atspi.NewObjectID(":1.20", "/desktop")
|
|
cell := atspi.NewSnapshot("/desktop/table/item", "Alpha", "table cell", "", "")
|
|
cell.BusName = window.BusName
|
|
cell.TableName = "Desktop items"
|
|
cell.TableRowCount, cell.TableColumnCount = 2, 2
|
|
cell.TableRowText, cell.GUITable = "Alpha, Document", true
|
|
activated := atspi.NewEvent(atspi.WindowActivatedEvent, cell)
|
|
activated.Window = window
|
|
activated.WindowTitle = "Desktop"
|
|
activated.WindowDescription = "Select an item and press Enter to open it."
|
|
adapter.events <- activated
|
|
table := atspi.NewSnapshot("/desktop/table", "Desktop items", "table", "", "")
|
|
table.BusName = window.BusName
|
|
table.TableRowCount, table.TableColumnCount = 2, 2
|
|
focused := atspi.NewEvent(atspi.FocusedStateEvent, table)
|
|
focused.Window = window
|
|
focused.Detail1 = 1
|
|
adapter.events <- focused
|
|
for index, expected := range []struct {
|
|
text string
|
|
append bool
|
|
}{
|
|
{"Desktop, Desktop items, table with 2 rows 2 columns, Alpha, Document, Select an item and press Enter to open it.", false},
|
|
{"Desktop items, table with 2 rows 2 columns", true},
|
|
} {
|
|
select {
|
|
case request := <-speech.requests:
|
|
if request.Text != expected.text || request.Append != expected.append {
|
|
t.Fatalf("request %d = %q append %t, want %q append %t", index, request.Text, request.Append, expected.text, expected.append)
|
|
}
|
|
case <-time.After(time.Second):
|
|
t.Fatalf("timed out waiting for request %d", index)
|
|
}
|
|
}
|
|
cancel()
|
|
<-completed
|
|
}
|
|
|
|
func TestTableDescriptionArrivingAfterActivation(t *testing.T) {
|
|
speech := &fakeSpeechQueue{spoken: make(chan string, 3), requests: make(chan speechRequest, 3)}
|
|
adapter := &fakeAdapter{events: make(chan atspi.Event, 3)}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
completed := make(chan struct{})
|
|
go func() {
|
|
processEvents(ctx, slog.New(slog.DiscardHandler), speech, adapter, 0)
|
|
close(completed)
|
|
}()
|
|
window := atspi.NewObjectID(":1.21", "/desktop")
|
|
table := atspi.NewSnapshot("/desktop/table", "Desktop items", "table", "", "")
|
|
table.BusName = window.BusName
|
|
activated := atspi.NewEvent(atspi.WindowActivatedEvent, table)
|
|
activated.Window = window
|
|
activated.WindowTitle = "Desktop"
|
|
adapter.events <- activated
|
|
first := <-speech.requests
|
|
if first.Text != "Desktop, Desktop items, table" {
|
|
t.Fatalf("activation = %q", first.Text)
|
|
}
|
|
table.TableRowCount, table.TableColumnCount = 2, 2
|
|
focused := atspi.NewEvent(atspi.FocusedStateEvent, table)
|
|
focused.Window = window
|
|
focused.WindowDescription = "Select an item and press Enter to open it."
|
|
focused.Detail1 = 1
|
|
adapter.events <- focused
|
|
second := <-speech.requests
|
|
if second.Text != "Desktop items, table with 2 rows 2 columns, Select an item and press Enter to open it." {
|
|
t.Fatalf("focused table = %q", second.Text)
|
|
}
|
|
cell := atspi.NewSnapshot("/desktop/table/first", "Alpha", "table cell", "", "")
|
|
cell.BusName = window.BusName
|
|
cell.TablePath = table.Path
|
|
cell.TableRowText, cell.GUITable = "Alpha, Document", true
|
|
cell.TablePositionKnown = true
|
|
third := atspi.NewEvent(atspi.FocusedStateEvent, cell)
|
|
third.Window = window
|
|
third.Detail1 = 1
|
|
adapter.events <- third
|
|
request := <-speech.requests
|
|
if request.Text != "Alpha, Document" || !request.Append {
|
|
t.Fatalf("following cell = %q append %t", request.Text, request.Append)
|
|
}
|
|
cancel()
|
|
<-completed
|
|
}
|
|
|
|
func TestGUITableHorizontalMovementReadsOneCell(t *testing.T) {
|
|
speech := &fakeSpeechQueue{spoken: make(chan string, 8), requests: make(chan speechRequest, 8)}
|
|
adapter := &fakeAdapter{events: make(chan atspi.Event, 8)}
|
|
inputs := &sequencedInputActivity{}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
completed := make(chan struct{})
|
|
go func() {
|
|
processEventsWithInput(ctx, slog.New(slog.DiscardHandler), speech, adapter,
|
|
nil, nil, 0, nil, inputs, nil, nil)
|
|
close(completed)
|
|
}()
|
|
window := atspi.NewObjectID(":1.22", "/desktop")
|
|
table := atspi.NewSnapshot("/desktop/table", "Desktop items", "table", "", "")
|
|
table.BusName = window.BusName
|
|
activated := atspi.NewEvent(atspi.WindowActivatedEvent, table)
|
|
activated.Window = window
|
|
adapter.events <- activated
|
|
<-speech.requests
|
|
cellEvent := func(path, name, rowText string, row, column int, eventType string) atspi.Event {
|
|
cell := atspi.NewSnapshot(path, name, "table cell", "", "")
|
|
cell.BusName = window.BusName
|
|
cell.TablePath = table.Path
|
|
cell.TableRowIndex, cell.TableColumnIndex = row, column
|
|
cell.TablePositionKnown, cell.GUITable = true, true
|
|
cell.TableRowText = rowText
|
|
event := atspi.NewManagedDescendantEvent(eventType, table.Path, cell)
|
|
event.Window = window
|
|
return event
|
|
}
|
|
for _, step := range []struct {
|
|
sequence uint64
|
|
event atspi.Event
|
|
want string
|
|
}{
|
|
{1, cellEvent("/desktop/table/alpha", "Alpha", "Alpha, Document", 0, 0, atspi.SelectionChangedEvent), "Alpha, Document"},
|
|
{2, cellEvent("/desktop/table/document", "Document", "Alpha, Document", 0, 1, atspi.ActiveDescendantEvent), "Document"},
|
|
{3, cellEvent("/desktop/table/alpha", "Alpha", "Alpha, Document", 0, 0, atspi.ActiveDescendantEvent), "Alpha"},
|
|
{4, cellEvent("/desktop/table/beta", "Beta", "Beta, Shortcut", 1, 0, atspi.SelectionChangedEvent), "Beta, Shortcut"},
|
|
{4, cellEvent("/desktop/table/replacement", "Renamed", "Renamed, Shortcut", 1, 0, atspi.ActiveDescendantEvent), "Renamed"},
|
|
} {
|
|
inputs.set(step.sequence)
|
|
adapter.events <- step.event
|
|
select {
|
|
case request := <-speech.requests:
|
|
if request.Text != step.want {
|
|
t.Fatalf("sequence %d = %q, want %q", step.sequence, request.Text, step.want)
|
|
}
|
|
case <-time.After(time.Second):
|
|
t.Fatalf("sequence %d produced no speech", step.sequence)
|
|
}
|
|
}
|
|
cancel()
|
|
<-completed
|
|
}
|
|
|
|
func TestGUITableReusedCurrentCellReadsReplacementRow(t *testing.T) {
|
|
speech := &fakeSpeechQueue{spoken: make(chan string, 4), requests: make(chan speechRequest, 4)}
|
|
adapter := &fakeAdapter{events: make(chan atspi.Event, 4)}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
completed := make(chan struct{})
|
|
go func() {
|
|
processEvents(ctx, slog.New(slog.DiscardHandler), speech, adapter, 0)
|
|
close(completed)
|
|
}()
|
|
defer func() { cancel(); <-completed }()
|
|
|
|
cell := atspi.NewSnapshot("/mail/messages/row", "First subject", "table cell", "", "")
|
|
cell.BusName = ":1.23"
|
|
cell.TablePath = "/mail/messages"
|
|
cell.TableRowIndex, cell.TableColumnIndex = 0, 0
|
|
cell.TablePositionKnown, cell.GUITable = true, true
|
|
cell.TableRowText = "First subject, First sender"
|
|
focus := atspi.NewEvent(atspi.FocusedStateEvent, cell)
|
|
focus.Detail1 = 1
|
|
adapter.events <- focus
|
|
if got := (<-speech.requests).Text; got != cell.TableRowText {
|
|
t.Fatalf("initial row = %q", got)
|
|
}
|
|
|
|
replacement := cell
|
|
replacement.Name = "Next subject"
|
|
replacement.TableRowText = "Next subject, Next sender"
|
|
selected := atspi.NewManagedDescendantEvent(atspi.SelectionChangedEvent, cell.TablePath, replacement)
|
|
adapter.events <- selected
|
|
select {
|
|
case request := <-speech.requests:
|
|
if request.Text != replacement.TableRowText {
|
|
t.Fatalf("replacement row = %q, want %q", request.Text, replacement.TableRowText)
|
|
}
|
|
case <-time.After(time.Second):
|
|
t.Fatal("replacement row was not spoken")
|
|
}
|
|
|
|
// A name event is another way a provider can expose a reused row.
|
|
third := replacement
|
|
third.Name = "Third subject"
|
|
third.TableRowText = "Third subject, Third sender"
|
|
nameChanged := atspi.NewEvent(atspi.AccessibleNameEvent, third)
|
|
adapter.events <- nameChanged
|
|
select {
|
|
case request := <-speech.requests:
|
|
if request.Text != third.TableRowText {
|
|
t.Fatalf("renamed row = %q, want %q", request.Text, third.TableRowText)
|
|
}
|
|
case <-time.After(time.Second):
|
|
t.Fatal("renamed current row was not spoken")
|
|
}
|
|
}
|