219 lines
8.2 KiB
Go
219 lines
8.2 KiB
Go
// Copyright (c) 2026 Storm Dragon
|
|
// Authors: Storm Dragon, Angus Kola
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
package input
|
|
|
|
import (
|
|
"errors"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
type repeatStep struct {
|
|
code uint8
|
|
pressed bool
|
|
stamp uint32
|
|
want []RemoteRepeatTransition
|
|
}
|
|
|
|
func down(code uint8) RemoteRepeatTransition {
|
|
return RemoteRepeatTransition{Keycode: code, Pressed: true}
|
|
}
|
|
func repeat(code uint8) RemoteRepeatTransition {
|
|
return RemoteRepeatTransition{Keycode: code, Pressed: true, Repeat: true}
|
|
}
|
|
func up(code uint8) RemoteRepeatTransition { return RemoteRepeatTransition{Keycode: code} }
|
|
|
|
func newTestNormalizer(t *testing.T) *RemoteRepeatNormalizer {
|
|
t.Helper()
|
|
normalizer, err := NewRemoteRepeatNormalizer(RemoteRepeatReleaseDelay)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return normalizer
|
|
}
|
|
|
|
func runRepeatSteps(t *testing.T, normalizer *RemoteRepeatNormalizer, now time.Time, steps []repeatStep) {
|
|
t.Helper()
|
|
for index, step := range steps {
|
|
got, err := normalizer.Observe(Event{Keycode: step.code, Pressed: step.pressed, Timestamp: step.stamp}, now)
|
|
if err != nil {
|
|
t.Fatalf("step %d: %v", index, err)
|
|
}
|
|
if len(got) == 0 && len(step.want) == 0 {
|
|
continue
|
|
}
|
|
if !reflect.DeepEqual(got, step.want) {
|
|
t.Fatalf("step %d: transitions = %+v, want %+v", index, got, step.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBehaviorRemoteRepeatNormalizesClassicPairs(t *testing.T) {
|
|
normalizer := newTestNormalizer(t)
|
|
now := time.Unix(100, 0)
|
|
runRepeatSteps(t, normalizer, now, []repeatStep{
|
|
{38, true, 100, []RemoteRepeatTransition{down(38)}},
|
|
{38, false, 660, nil}, // Classic pair: release held.
|
|
{38, true, 660, []RemoteRepeatTransition{repeat(38)}},
|
|
{38, false, 700, nil},
|
|
{38, true, 700, []RemoteRepeatTransition{repeat(38)}},
|
|
{38, false, 750, nil}, // Real release: no matching press follows.
|
|
{39, true, 760, []RemoteRepeatTransition{up(38), down(39)}},
|
|
{39, false, 770, nil},
|
|
{39, true, 780, []RemoteRepeatTransition{up(39), down(39)}}, // Different stamp is a fresh press.
|
|
})
|
|
if _, pending := normalizer.Deadline(); pending {
|
|
t.Fatal("fresh press left a pending release")
|
|
}
|
|
}
|
|
|
|
func TestBehaviorRemoteRepeatPassesDetectableRepeat(t *testing.T) {
|
|
normalizer := newTestNormalizer(t)
|
|
runRepeatSteps(t, normalizer, time.Unix(1, 0), []repeatStep{
|
|
{50, true, 10, []RemoteRepeatTransition{down(50)}},
|
|
{50, true, 20, []RemoteRepeatTransition{repeat(50)}},
|
|
{50, true, 30, []RemoteRepeatTransition{repeat(50)}},
|
|
{38, true, 40, []RemoteRepeatTransition{down(38)}},
|
|
{38, false, 0, []RemoteRepeatTransition{up(38)}}, // Unknown stamp releases immediately.
|
|
{38, true, 0, []RemoteRepeatTransition{down(38)}},
|
|
})
|
|
}
|
|
|
|
func TestBehaviorRemoteRepeatPendingReleaseFlushesAtDeadline(t *testing.T) {
|
|
normalizer := newTestNormalizer(t)
|
|
start := time.Unix(5, 0)
|
|
runRepeatSteps(t, normalizer, start, []repeatStep{
|
|
{38, true, 100, []RemoteRepeatTransition{down(38)}},
|
|
{38, false, 200, nil},
|
|
})
|
|
deadline, pending := normalizer.Deadline()
|
|
if !pending || !deadline.Equal(start.Add(RemoteRepeatReleaseDelay)) {
|
|
t.Fatalf("deadline = %v %t", deadline, pending)
|
|
}
|
|
if got := normalizer.Flush(deadline.Add(-time.Nanosecond)); got != nil {
|
|
t.Fatalf("early flush = %+v", got)
|
|
}
|
|
if got := normalizer.Flush(deadline); !reflect.DeepEqual(got, []RemoteRepeatTransition{up(38)}) {
|
|
t.Fatalf("flush = %+v", got)
|
|
}
|
|
if got := normalizer.Flush(deadline.Add(time.Second)); got != nil {
|
|
t.Fatalf("repeated flush = %+v", got)
|
|
}
|
|
// A press with the old stamp after the flush is a fresh, owned press.
|
|
runRepeatSteps(t, normalizer, deadline, []repeatStep{
|
|
{38, true, 200, []RemoteRepeatTransition{down(38)}},
|
|
})
|
|
if got := normalizer.Retire(); !reflect.DeepEqual(got, []RemoteRepeatTransition{up(38)}) {
|
|
t.Fatalf("retire = %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestBehaviorRemoteRepeatSuppressesUnownedReleases(t *testing.T) {
|
|
normalizer := newTestNormalizer(t)
|
|
runRepeatSteps(t, normalizer, time.Unix(1, 0), []repeatStep{
|
|
{64, false, 10, nil}, // Held before capture began.
|
|
{64, false, 0, nil},
|
|
{38, true, 20, []RemoteRepeatTransition{down(38)}},
|
|
{38, false, 30, nil},
|
|
{64, false, 31, []RemoteRepeatTransition{up(38)}}, // Pending release flushed; unowned up suppressed.
|
|
})
|
|
if _, pending := normalizer.Deadline(); pending {
|
|
t.Fatal("unowned release became pending")
|
|
}
|
|
if got := normalizer.Retire(); len(got) != 0 {
|
|
t.Fatalf("retire released unowned keys: %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestBehaviorRemoteRepeatRetireReleasesReverseOrderOnce(t *testing.T) {
|
|
normalizer := newTestNormalizer(t)
|
|
runRepeatSteps(t, normalizer, time.Unix(1, 0), []repeatStep{
|
|
{50, true, 1, []RemoteRepeatTransition{down(50)}},
|
|
{37, true, 2, []RemoteRepeatTransition{down(37)}},
|
|
{38, true, 3, []RemoteRepeatTransition{down(38)}},
|
|
{37, false, 4, nil}, // Pending release is still owned at retirement.
|
|
})
|
|
want := []RemoteRepeatTransition{up(38), up(37), up(50)}
|
|
if got := normalizer.Retire(); !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("retire = %+v, want %+v", got, want)
|
|
}
|
|
if got := normalizer.Retire(); got != nil {
|
|
t.Fatalf("second retire = %+v", got)
|
|
}
|
|
if _, pending := normalizer.Deadline(); pending {
|
|
t.Fatal("retired normalizer kept a deadline")
|
|
}
|
|
if got := normalizer.Flush(time.Unix(100, 0)); got != nil {
|
|
t.Fatalf("retired flush = %+v", got)
|
|
}
|
|
if _, err := normalizer.Observe(Event{Keycode: 38, Pressed: true, Timestamp: 9}, time.Unix(2, 0)); !errors.Is(err, ErrRemoteKeyState) {
|
|
t.Fatalf("observe after retire = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestBehaviorRemoteRepeatStopsOnInvalidOrExcessKeys(t *testing.T) {
|
|
normalizer := newTestNormalizer(t)
|
|
now := time.Unix(1, 0)
|
|
runRepeatSteps(t, normalizer, now, []repeatStep{{38, true, 1, []RemoteRepeatTransition{down(38)}}})
|
|
if _, err := normalizer.Observe(Event{Keycode: 7, Pressed: true, Timestamp: 2}, now); !errors.Is(err, ErrRemoteKeyUnavailable) {
|
|
t.Fatalf("invalid keycode = %v", err)
|
|
}
|
|
if _, err := normalizer.Observe(Event{Keycode: 39, Pressed: true, Timestamp: 3}, now); !errors.Is(err, ErrRemoteKeyState) {
|
|
t.Fatalf("stopped admission = %v", err)
|
|
}
|
|
if got := normalizer.Retire(); !reflect.DeepEqual(got, []RemoteRepeatTransition{up(38)}) {
|
|
t.Fatalf("retire after invalid = %+v", got)
|
|
}
|
|
|
|
normalizer = newTestNormalizer(t)
|
|
for index := 0; index < RemoteHeldKeyLimit; index++ {
|
|
code := uint8(remoteRepeatMinKeycode + index)
|
|
runRepeatSteps(t, normalizer, now, []repeatStep{{code, true, uint32(index + 1), []RemoteRepeatTransition{down(code)}}})
|
|
}
|
|
// Repeats of owned keys remain admissible at the limit.
|
|
runRepeatSteps(t, normalizer, now, []repeatStep{{8, true, 100, []RemoteRepeatTransition{repeat(8)}}})
|
|
// A release followed by a different fresh key emits the release before the
|
|
// limit is checked again, so the new key fits.
|
|
runRepeatSteps(t, normalizer, now, []repeatStep{
|
|
{8, false, 101, nil},
|
|
{200, true, 102, []RemoteRepeatTransition{up(8), down(200)}},
|
|
})
|
|
if _, err := normalizer.Observe(Event{Keycode: 201, Pressed: true, Timestamp: 103}, now); !errors.Is(err, ErrRemoteKeyLimit) {
|
|
t.Fatalf("overflow = %v", err)
|
|
}
|
|
got := normalizer.Retire()
|
|
if len(got) != RemoteHeldKeyLimit || got[0] != up(200) || got[len(got)-1] != up(9) {
|
|
t.Fatalf("retire after overflow = %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestBehaviorRemoteRepeatPendingDoesNotPairOtherKeysOrReleases(t *testing.T) {
|
|
normalizer := newTestNormalizer(t)
|
|
runRepeatSteps(t, normalizer, time.Unix(1, 0), []repeatStep{
|
|
{38, true, 1, []RemoteRepeatTransition{down(38)}},
|
|
{39, true, 2, []RemoteRepeatTransition{down(39)}},
|
|
{38, false, 10, nil},
|
|
{39, true, 10, []RemoteRepeatTransition{up(38), repeat(39)}}, // Same stamp, other key.
|
|
{39, false, 11, nil},
|
|
{39, false, 11, []RemoteRepeatTransition{up(39)}}, // Duplicate release is unowned once flushed.
|
|
})
|
|
}
|
|
|
|
func TestBehaviorRemoteRepeatRejectsInvalidDelay(t *testing.T) {
|
|
for _, delay := range []time.Duration{0, -time.Millisecond, RemoteRepeatReleaseDelayMax + time.Nanosecond} {
|
|
if _, err := NewRemoteRepeatNormalizer(delay); !errors.Is(err, ErrRemoteRepeatDelay) {
|
|
t.Fatalf("delay %v: %v", delay, err)
|
|
}
|
|
}
|
|
var normalizer *RemoteRepeatNormalizer
|
|
if _, err := normalizer.Observe(Event{Keycode: 38, Pressed: true}, time.Time{}); !errors.Is(err, ErrRemoteKeyState) {
|
|
t.Fatalf("nil observe = %v", err)
|
|
}
|
|
if normalizer.Retire() != nil || normalizer.Flush(time.Time{}) != nil {
|
|
t.Fatal("nil normalizer emitted transitions")
|
|
}
|
|
}
|