Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
package remoteinput
import (
"archive/zip"
"bytes"
"context"
"crypto/rand"
"encoding/base64"
"encoding/binary"
"encoding/hex"
"encoding/json"
"errors"
"io"
"log/slog"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/TNTcraftHIM/Piik/internal/app/nativecapture"
"github.com/TNTcraftHIM/Piik/internal/diagnostics"
"github.com/TNTcraftHIM/Piik/internal/media/inputroute"
"github.com/TNTcraftHIM/Piik/internal/server/protocol"
"github.com/pion/webrtc/v4"
)
func TestInputDiagnosticsDistinguishStagesWithoutInputValues(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 32), resets: make(chan struct{}, 16), focused: true}
m := &Manager{sink: sink, gamepads: &recordedGamepads{}, connections: map[endpointKey]*connection{}}
s, peers := coPlaySession(t, m, true)
c := peers[0]
packet := func(plain []byte) {
header := make([]byte, 20)
binary.BigEndian.PutUint64(header, c.cipher.received+1)
_, _ = rand.Read(header[8:])
data := c.cipher.aead.Seal(header, header[8:], plain, inputAAD(0, header[:8], c.epoch))
s.receivePacket(c.edgeID, inputroute.Packet{ID: c.id, Epoch: c.epoch, Data: base64.StdEncoding.EncodeToString(data)}, nil)
}
input := func(event inputEvent) {
if event.Grant == "" {
event.Grant = c.grant
}
data, _ := json.Marshal(event)
packet(data)
}
before := m.Diagnostics()
s.receivePacket(c.edgeID, inputroute.Packet{ID: c.id, Epoch: c.epoch, Data: "not-base64"}, nil)
packet([]byte("not-json"))
input(inputEvent{Type: "request", Intent: strings.Repeat("f", 32)})
input(inputEvent{Type: "move", Grant: "wrong-grant", X: .37, Y: .29})
sink.focused = false
input(inputEvent{Type: "move", X: .37, Y: .29})
suspended := m.Diagnostics()
if suspended.ActiveGrants != 0 || suspended.SuspendedGrants != 1 || len(sink.events) != 0 ||
suspended.Counters.Mouse != (DiagnosticFamilyCounters{Parsed: 2, Authorized: 1}) {
t.Fatalf("quiet target suspension lost its stage: %+v", suspended)
}
sink.focused = true
input(inputEvent{Type: "move", X: .37, Y: .29})
sink.applyErr = errors.New("test sink rejection")
input(inputEvent{Type: "button", Down: true})
sink.applyErr = nil
input(inputEvent{Type: "button", Down: true})
input(inputEvent{Type: "button", Down: true}) // Held deduplication is not another API acceptance.
input(inputEvent{Type: "key", Code: "KeyZ", Down: true})
accepted := m.Diagnostics()
if accepted.Counters.ReceivedPackets-before.Counters.ReceivedPackets != 10 ||
accepted.Counters.DecryptedPackets-before.Counters.DecryptedPackets != 9 ||
accepted.Counters.ParsedEvents-before.Counters.ParsedEvents != 8 ||
accepted.Counters.Mouse != (DiagnosticFamilyCounters{Parsed: 6, Authorized: 5, TargetReady: 4, APIAttempts: 3, APIAccepted: 2, APIRejected: 1}) ||
accepted.Counters.Keyboard != (DiagnosticFamilyCounters{Parsed: 1, Authorized: 1, TargetReady: 1, APIAttempts: 1, APIAccepted: 1}) ||
accepted.ActiveGrants != 1 || accepted.SuspendedGrants != 0 {
t.Fatalf("ingress, authorization and sink API results were conflated: %+v", accepted)
}
sink.applyErr = errors.New("test release rejection")
input(inputEvent{Type: "key", Code: "KeyZ"})
input(inputEvent{Type: "button"})
pending := m.Diagnostics()
if pending.PendingKeyReleases != 1 || pending.PendingButtonReleases != 1 {
t.Fatalf("release counts missing: %+v", pending)
}
// Export the actual bounded report context. The snapshot must not retry the
// rejected cleanup or expose the held input, credentials, or connection IDs.
events, grant := len(sink.events), c.grant
recorder, err := diagnostics.Open(t.TempDir(), "client", "test")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = recorder.Close() })
recorder.Context("remoteInput", m.Diagnostics())
path, err := recorder.Export()
if err != nil {
t.Fatal(err)
}
archive, err := zip.OpenReader(path)
if err != nil {
t.Fatal(err)
}
defer archive.Close()
var content []byte
for _, file := range archive.File {
if file.Name == "context.json" {
reader, err := file.Open()
if err != nil {
t.Fatal(err)
}
content, err = io.ReadAll(reader)
reader.Close()
if err != nil {
t.Fatal(err)
}
}
}
var context struct {
RemoteInput DiagnosticSnapshot `json:"remoteInput"`
}
if err := json.Unmarshal(content, &context); err != nil || context.RemoteInput != pending {
t.Fatalf("ZIP omitted the current input counts: %s, %v", content, err)
}
for _, private := range []string{grant, c.secret, c.id, c.peerID, "KeyZ", `"x":`, `"y":`, `"text":`, `"code":`} {
if strings.Contains(string(content), private) {
t.Fatalf("diagnostic context contains input values or identity: %q", private)
}
}
t.Logf("exported input diagnostic context: %s", content)
if m.Diagnostics() != pending || len(sink.events) != events || c.grant != grant {
t.Fatal("observing/exporting diagnostics changed input or cleanup state")
}
sink.applyErr = nil
if err := m.retryReleases(); err != nil {
t.Fatal(err)
}
}
type recordedInput struct {
authorize func() error
events chan inputEvent
resets chan struct{}
target bounds
geometry bounds
focused bool
targetErr error
applyErr error
resetErr error
}
func receiveTestInput(m *Manager, c *connection, plain []byte) {
m.mu.Lock()
defer m.mu.Unlock()
m.receiveLocked(c, plain)
}
func revokeTestEdge(s *Session, edgeID string) {
s.manager.mu.Lock()
defer s.manager.mu.Unlock()
s.revokeEdgeLocked(edgeID)
}
func setTestPolicy(s *Session, mode, password string) error {
change, err := s.BeginPolicy(context.Background(), mode, password, s.coPlay)
if err != nil {
return err
}
defer change.Close()
return change.Apply()
}
func TestSourceAuthorizationPolicy(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 20), resets: make(chan struct{}, 20), focused: true}
m := &Manager{sink: sink, connections: map[endpointKey]*connection{}}
s := m.NewSession()
t.Cleanup(s.Close)
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "1"}, nil)
peers := []protocol.RemoteInputPeer{
{PeerID: "first-viewer", EndpointID: strings.Repeat("a", 32), Secret: strings.Repeat("b", 64)},
{PeerID: "second-viewer", EndpointID: strings.Repeat("c", 32), Secret: strings.Repeat("d", 64)},
}
if err := s.SetPeers(peers); err != nil {
t.Fatal(err)
}
first, second := m.connections[endpointKey{s, peers[0].EndpointID}], m.connections[endpointKey{s, peers[1].EndpointID}]
for _, c := range []*connection{first, second} {
c.edgeID, c.epoch = "root-edge", strings.Repeat("e", 32)
}
request := func(c *connection, password string) {
t.Helper()
data, _ := json.Marshal(inputEvent{Type: "request", Intent: strings.Repeat("f", 32), Password: password})
header := make([]byte, 20)
binary.BigEndian.PutUint64(header, c.cipher.received+1)
_, _ = rand.Read(header[8:])
data = c.cipher.aead.Seal(header, header[8:], data, inputAAD(0, header[:8], c.epoch))
s.receivePacket(c.edgeID, inputroute.Packet{ID: c.id, Epoch: c.epoch, Data: base64.StdEncoding.EncodeToString(data)}, nil)
}
request(first, "")
if s.State().Mode != "off" || first.requested || m.owner != nil {
t.Fatal("ordinary sharing accepted a control request before opt-in")
}
if err := setTestPolicy(s, "ask", ""); err != nil {
t.Fatal(err)
}
request(first, "")
oldRequest := first.requestID
if !first.requested || m.owner != nil {
t.Fatal("Ask each time did not require Host approval")
}
if err := setTestPolicy(s, "room", ""); err != nil {
t.Fatal(err)
}
if m.owner != nil || first.requested || s.Decide(oldRequest, true) == nil {
t.Fatal("policy change inherited an old request")
}
request(first, "")
if first.grant == "" {
t.Fatal("explicit room policy did not grant control")
}
request(second, "")
if first.grant == "" || second.grant != "" || second.requested {
t.Fatal("automatic request displaced an active controller")
}
m.Revoke()
if m.owner != nil || s.State().Mode != "ask" {
t.Fatal("local stop did not disable automatic access")
}
request(second, "")
if !second.requested || m.owner != nil {
t.Fatal("local stop allowed automatic re-entry")
}
if setTestPolicy(s, "password", "") == nil {
t.Fatal("password mode accepted an empty credential")
}
if err := setTestPolicy(s, "password", "shared-secret"); err != nil {
t.Fatal(err)
}
request(first, "wrong")
if m.owner != nil || first.requested {
t.Fatal("incorrect password acquired control")
}
request(second, "shared-secret")
if m.owner != nil {
t.Fatal("changing endpoints bypassed password attempt pacing")
}
s.passwordRetry = time.Time{}
request(first, "shared-secret")
if first.grant == "" {
t.Fatal("correct password did not authorize control")
}
if err := s.Decide(first.requestID, false); err != nil {
t.Fatal(err)
}
if m.owner != nil || s.State().Mode != "ask" {
t.Fatal("Host stop left automatic access enabled")
}
if err := setTestPolicy(s, "room", ""); err != nil {
t.Fatal(err)
}
request(first, "")
revokeTestEdge(s, "root-edge")
if m.owner != nil {
t.Fatal("route loss retained input")
}
request(first, "")
if first.grant == "" {
t.Fatal("room policy could not authorize a fresh request")
}
oldGrant := first.grant
s.Pause(true)
if err := setTestPolicy(s, "off", ""); err != nil {
t.Fatal(err)
}
s.Pause(false)
receiveTestInput(m, first, []byte(`{"type":"key","code":"KeyA","down":true,"grant":"`+oldGrant+`"}`))
request(second, "")
if m.owner != nil || second.requested || len(sink.events) != 0 {
t.Fatal("disabled remote control retained input or accepted a new request")
}
if err := setTestPolicy(s, "room", ""); err != nil {
t.Fatal(err)
}
request(first, "")
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "2"}, nil)
if m.owner != nil || s.State().Mode != "off" {
t.Fatal("source replacement inherited permission")
}
request(second, "")
if second.requested || m.owner != nil {
t.Fatal("replacement source accepted input without opt-in")
}
if err := setTestPolicy(s, "room", ""); err != nil {
t.Fatal(err)
}
request(first, "")
revokedGrant := first.grant
if err := s.SetPeers(peers[1:]); err != nil {
t.Fatal(err)
}
if m.owner != nil || first.grant != "" || m.connections[endpointKey{s, first.id}] != nil {
t.Fatal("room membership removal retained the active input grant")
}
receiveTestInput(m, first, []byte(`{"type":"key","code":"KeyA","down":true,"grant":"`+revokedGrant+`"}`))
request(first, "")
if m.owner != nil || first.requested || len(sink.events) != 0 {
t.Fatal("removed endpoint regained input with its old grant or key")
}
request(second, "")
if second.grant == "" {
t.Fatal("membership removal interrupted the remaining authenticated endpoint")
}
}
func TestRouteReplacementRequiresApprovalAndIgnoresOldClosure(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 8), resets: make(chan struct{}, 8), focused: true}
m := &Manager{sink: sink, connections: map[endpointKey]*connection{}}
s := m.NewSession()
t.Cleanup(s.Close)
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "1"}, nil)
if err := setTestPolicy(s, "ask", ""); err != nil {
t.Fatal(err)
}
peer := protocol.RemoteInputPeer{PeerID: "viewer-route-test", EndpointID: strings.Repeat("a", 32), Secret: strings.Repeat("b", 64)}
if err := s.SetPeers([]protocol.RemoteInputPeer{peer}); err != nil {
t.Fatal(err)
}
cipher, _ := newInputCipher(peer.Secret)
request := func(epoch string) string {
t.Helper()
cipher.sent++
header := make([]byte, 20)
binary.BigEndian.PutUint64(header, cipher.sent)
_, _ = rand.Read(header[8:])
plain := []byte(`{"type":"request","intent":"` + epoch + `"}`)
data := cipher.aead.Seal(header, header[8:], plain, inputAAD(0, header[:8], epoch))
s.receivePacket("same-root-relay", inputroute.Packet{ID: peer.EndpointID, Epoch: epoch, Data: base64.StdEncoding.EncodeToString(data)}, nil)
views := s.State().Requests
if len(views) != 1 || views[0].State != "pending" {
t.Fatal("new channel did not require fresh approval")
}
if err := s.Decide(views[0].ID, true); err != nil {
t.Fatal(err)
}
return m.connections[endpointKey{s, peer.EndpointID}].grant
}
oldEpoch, newEpoch := strings.Repeat("c", 32), strings.Repeat("d", 32)
oldGrant := request(oldEpoch)
newGrant := request(newEpoch)
if oldGrant == newGrant || len(sink.resets) != 1 {
t.Fatal("replacement retained old input")
}
s.receivePacket("same-root-relay", inputroute.Packet{ID: peer.EndpointID, Epoch: oldEpoch, Closed: true}, nil)
if m.owner == nil || m.connections[endpointKey{s, peer.EndpointID}].grant != newGrant {
t.Fatal("old descendant closure retired the new grant")
}
s.receivePacket("same-root-relay", inputroute.Packet{ID: peer.EndpointID, Epoch: newEpoch, Closed: true}, nil)
if m.owner != nil || len(sink.resets) != 2 {
t.Fatal("current route loss did not release input")
}
}
func (s *recordedInput) Authorize() error {
if s.authorize != nil {
return s.authorize()
}
return nil
}
func TestOSPermissionCannotAuthorizeAReplacementSource(t *testing.T) {
sink := &recordedInput{}
m := &Manager{sink: sink, connections: map[endpointKey]*connection{}}
s := m.NewSession()
t.Cleanup(s.Close)
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "1"}, nil)
sink.authorize = func() error {
// Closing/replacing the share must remain possible while an OS dialog is open.
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "2"}, nil)
return nil
}
if setTestPolicy(s, "room", "") == nil || s.State().Mode != "off" {
t.Fatal("late OS permission enabled input on a replacement source")
}
sink.authorize = func() error { return setTestPolicy(s, "off", "") }
if setTestPolicy(s, "room", "") == nil || s.State().Mode != "off" {
t.Fatal("late OS permission undid Host revocation")
}
}
func TestPreparedPolicyFollowsTheCommittedSourceAndHostIntent(t *testing.T) {
for _, action := range []string{"complete", "off-before-work", "off-during-prepare", "pause-and-resume", "replace-source"} {
t.Run(action, func(t *testing.T) {
sink := &recordedInput{}
m := &Manager{sink: sink, connections: map[endpointKey]*connection{}}
s := m.NewSession()
t.Cleanup(s.Close)
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "1"}, nil)
change, err := s.BeginPolicy(t.Context(), "room", "", false)
if err != nil {
t.Fatal(err)
}
defer change.Close()
if action == "off-before-work" {
if err := setTestPolicy(s, "off", ""); err != nil {
t.Fatal(err)
}
}
// Portal capture replacement must retire input while preserving only
// the same current Host intent through its own two source bindings.
change.SetTarget(nativecapture.CaptureTarget{}, nil)
switch action {
case "off-during-prepare":
if err := setTestPolicy(s, "off", ""); err != nil {
t.Fatal(err)
}
case "pause-and-resume":
s.Pause(true)
s.Pause(false)
case "replace-source":
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "2"}, nil)
}
installed := nativecapture.CaptureTarget{Kind: "display", SourceID: "3"}
change.SetTarget(installed, nil)
cancelled := action != "complete"
if (change.Context().Err() != nil) != cancelled {
t.Fatal("preparation cancellation did not follow the Host intent")
}
if (change.Apply() != nil) != cancelled {
t.Fatal("late preparation changed a retired permission")
}
expected := "room"
if cancelled {
expected = "off"
}
if s.State().Mode != expected || s.target != installed {
t.Fatal("policy or actual source binding diverged after preparation")
}
if err := setTestPolicy(s, "ask", ""); err != nil {
t.Fatalf("new authorization could not use the committed source: %v", err)
}
})
}
}
func (s *recordedInput) Target(nativecapture.CaptureTarget, *nativecapture.Stream) (bounds, bool, error) {
return s.geometry, s.focused, s.targetErr
}
func (s *recordedInput) Apply(target bounds, event inputEvent) error {
if s.applyErr != nil {
return s.applyErr
}
s.target = target
s.events <- event
return nil
}
func (s *recordedInput) Reset() error {
if s.resets != nil {
s.resets <- struct{}{}
}
return s.resetErr
}
func TestInputFailureDiagnosticsPreserveExecutionAuthority(t *testing.T) {
for _, stage := range []string{"target", "apply"} {
t.Run(stage, func(t *testing.T) {
var logs bytes.Buffer
previous := slog.Default()
slog.SetDefault(slog.New(slog.NewJSONHandler(&logs, &slog.HandlerOptions{Level: slog.LevelDebug})))
t.Cleanup(func() { slog.SetDefault(previous) })
sink := &recordedInput{events: make(chan inputEvent, 8), resets: make(chan struct{}, 8), focused: true}
m := &Manager{sink: sink, connections: map[endpointKey]*connection{}}
_, peers := coPlaySession(t, m, true)
c := peers[0]
sendTestInput(m, c, inputEvent{Type: "request", Intent: strings.Repeat("f", 32)})
grant := c.grant
if grant == "" {
t.Fatal("control was not granted")
}
sendTestInput(m, c, inputEvent{Type: "key", Code: "KeyA", Down: true, Grant: grant})
failure := errors.New("platform input failed")
if stage == "target" {
sink.targetErr = failure
} else {
sink.applyErr = failure
}
sendTestInput(m, c, inputEvent{Type: "text", Text: "private committed text", Grant: grant})
if stage == "target" {
if m.owner != nil || c.grant != "" || len(c.keys) != 0 {
t.Fatal("invalid target retained authority")
}
} else if m.owner == nil || c.grant != grant || !c.inputFailed {
t.Fatal("execution failure retired authorization or hid failure")
}
var record map[string]any
if err := json.Unmarshal(logs.Bytes(), &record); err != nil {
t.Fatalf("expected one failure record: %v", err)
}
if record["event"] != stage+"-failed" || record["connectionId"] != diagnostics.ID(c.edgeID) || record["inputGeneration"] != diagnostics.ID(c.epoch) {
t.Fatalf("failure stage or generation missing: %v", record)
}
if stage == "apply" {
if record["operation"] != "text" || record["sourceKind"] != c.owner.target.Kind {
t.Fatal("failure lost its operation or target kind")
}
if _, ok := record["targetReady"].(bool); !ok {
t.Fatal("failure lost its target observation")
}
}
for _, private := range []string{grant, c.intent, c.edgeID, c.epoch, "KeyA", "private committed text"} {
if strings.Contains(logs.String(), private) {
t.Fatal("failure diagnostic recorded private input or authority")
}
}
})
}
}
func TestCommittedMultilineText(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 16), resets: make(chan struct{}, 8)}
longLine := strings.Repeat("\\\"", maxTextBytes/2)
for _, text := range []string{longLine, "if (ready) {\r\n\tprint(\"中文 😀\");\n}"} {
if err := applyText(sink, bounds{}, text); err != nil {
t.Fatal(err)
}
}
want := []inputEvent{
{Type: "text", Text: longLine},
{Type: "text", Text: "if (ready) {"},
{Type: "key", Code: "Enter", Down: true}, {Type: "key", Code: "Enter"},
{Type: "key", Code: "Tab", Down: true}, {Type: "key", Code: "Tab"},
{Type: "text", Text: "print(\"中文 😀\");"},
{Type: "key", Code: "Enter", Down: true}, {Type: "key", Code: "Enter"},
{Type: "text", Text: "}"},
}
if len(sink.events) != len(want) {
t.Fatalf("input events: %d, want %d", len(sink.events), len(want))
}
for _, event := range want {
if actual := <-sink.events; actual != event {
t.Fatalf("input: %+v, want %+v", actual, event)
}
}
for _, text := range []string{"", strings.Repeat("x", maxTextBytes+1), "a\x00b", "a\x7fb", string([]byte{0xff})} {
if err := applyText(sink, bounds{}, text); err == nil {
t.Fatal("invalid text accepted")
}
}
if len(sink.events) != 0 || len(sink.resets) != 2 {
t.Fatal("invalid text applied partial input or reset held keys")
}
}
func coPlaySession(t *testing.T, m *Manager, extended ...bool) (*Session, []*connection) {
t.Helper()
t.Cleanup(m.Close)
s := m.NewSession()
t.Cleanup(s.Close)
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "1"}, nil)
change, err := s.BeginPolicy(t.Context(), "room", "", true)
if err != nil {
t.Fatal(err)
}
defer change.Close()
if err := change.Apply(); err != nil {
t.Fatal(err)
}
if state := s.State(); state.Simultaneous == nil || *state.Simultaneous {
t.Fatal("new source enabled concurrent control by default")
}
if err := s.SetSimultaneous(true); err != nil {
t.Fatal(err)
}
var peers []protocol.RemoteInputPeer
for i := range extended {
digit := hex.EncodeToString([]byte{byte(i + 1)})
peers = append(peers, protocol.RemoteInputPeer{PeerID: "viewer-" + string(rune('a'+i)),
EndpointID: strings.Repeat(digit, 16), Secret: strings.Repeat(digit, 32)})
}
if err := s.SetPeers(peers); err != nil {
t.Fatal(err)
}
var connections []*connection
for i, peer := range peers {
c := m.connections[endpointKey{s, peer.EndpointID}]
c.edgeID, c.epoch = c.id, strings.Repeat("e", 32)
if extended[i] {
sendTestInput(m, c, inputEvent{Type: "capabilities"})
}
connections = append(connections, c)
}
return s, connections
}
type recordedGamepad struct {
state gamepadReport
updateErr error
closed bool
}
func (p *recordedGamepad) Update(report gamepadReport) error {
if p.closed {
return errors.New("recorded gamepad is closed")
}
if p.updateErr != nil {
return p.updateErr
}
p.state = report
return nil
}
func (p *recordedGamepad) Close() error {
if p.closed {
return nil
}
err := p.Update(gamepadReport{})
p.closed = true
return err
}
type recordedGamepads struct {
devices []*recordedGamepad
capacity int
openErr error
closed bool
}
func (b *recordedGamepads) Open() (gamepadDevice, error) {
if b.capacity > 0 {
active := 0
for _, device := range b.devices {
if !device.closed {
active++
}
}
if active >= b.capacity {
return nil, errors.New("backend device capacity reached")
}
}
if b.openErr != nil {
return nil, b.openErr
}
p := &recordedGamepad{}
b.devices = append(b.devices, p)
return p, nil
}
func (b *recordedGamepads) Close() error {
b.closed = true
for _, device := range b.devices {
_ = device.Close()
}
return nil
}
func TestCoPlayGamepadGrantIsolationAndRetirement(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 32), resets: make(chan struct{}, 16), focused: true}
pads := &recordedGamepads{}
m := &Manager{sink: sink, gamepads: pads, connections: map[endpointKey]*connection{}}
s, players := coPlaySession(t, m, true, true, true)
a, b, keyboard := players[0], players[1], players[2]
for _, c := range players {
sendTestInput(m, c, inputEvent{Type: "request"})
}
if a.grant == "" || b.grant == "" || keyboard.grant == "" || len(pads.devices) != 0 {
t.Fatal("one permission did not grant input without allocating gamepads")
}
reportA := gamepadReport{Buttons: 0x1000, LeftX: 12000}
reportB := gamepadReport{Buttons: 0x2000, RightTrigger: 190}
sendTestInput(m, a, inputEvent{Type: "gamepad-reset"})
if len(pads.devices) != 0 {
t.Fatal("reset allocated a gamepad")
}
sendTestInput(m, a, inputEvent{Type: "gamepad", Gamepad: &reportA})
sendTestInput(m, b, inputEvent{Type: "gamepad", Gamepad: &reportB})
first, second := pads.devices[0], pads.devices[1]
if first.state != reportA || second.state != reportB {
t.Fatal("gamepad reports crossed grant ownership")
}
for _, view := range s.State().Requests {
if view.EndpointID == "" {
t.Fatal("Host presentation lost the authenticated endpoint")
}
}
sendTestInput(m, a, inputEvent{Type: "key", Code: "KeyA", Down: true})
<-sink.events
sendTestInput(m, a, inputEvent{Type: "gamepad-reset"})
if first.state != (gamepadReport{}) || second.state != reportB || !a.keys["KeyA"] {
t.Fatal("gamepad reset changed keys or another participant")
}
sendTestInput(m, a, inputEvent{Type: "gamepad", Gamepad: &reportA})
sendTestInput(m, a, inputEvent{Type: "reset"})
if first.state != (gamepadReport{}) || len(a.keys) != 0 {
t.Fatal("whole input reset retained held input")
}
<-sink.events
sink.focused = false
m.refreshActive()
if !a.suspended || !b.suspended || !keyboard.suspended || second.state != (gamepadReport{}) || first.closed || second.closed {
t.Fatal("focus loss did not neutralize all input")
}
sendTestInput(m, b, inputEvent{Type: "gamepad", Gamepad: &reportB})
if second.state != (gamepadReport{}) {
t.Fatal("unfocused source accepted gamepad input")
}
sink.focused = true
sendTestInput(m, b, inputEvent{Type: "gamepad", Gamepad: &reportB})
if a.pad != first || b.pad != second || len(pads.devices) != 2 {
t.Fatal("focus recovery replaced a player's virtual device")
}
sendTestInput(m, keyboard, inputEvent{Type: "key", Code: "KeyB", Down: true})
<-sink.events
s.receivePacket(a.edgeID, inputroute.Packet{ID: a.id, Epoch: a.epoch, Closed: true}, nil)
if !first.closed || a.grant != "" || b.grant == "" || !keyboard.keys["KeyB"] {
t.Fatal("one route loss affected another participant")
}
second.updateErr = errors.New("driver write failed")
sendTestInput(m, b, inputEvent{Type: "gamepad", Gamepad: &reportB})
if !second.closed || b.pad != nil || b.grant == "" || !b.padFailed || !keyboard.keys["KeyB"] {
t.Fatal("gamepad failure changed healthy input authorization")
}
sendTestInput(m, b, inputEvent{Type: "gamepad", Gamepad: &reportB})
if len(pads.devices) != 2 {
t.Fatal("failed gamepad retried allocation")
}
sendTestInput(m, b, inputEvent{Type: "key", Code: "KeyC", Down: true})
<-sink.events
if !b.keys["KeyC"] {
t.Fatal("gamepad failure disabled keyboard input")
}
a.edgeID = "replacement-edge"
sendTestInput(m, a, inputEvent{Type: "request"})
sendTestInput(m, a, inputEvent{Type: "gamepad", Gamepad: &reportA})
third := pads.devices[2]
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "2"}, nil)
if !third.closed || third.state != (gamepadReport{}) || a.grant != "" || keyboard.grant != "" || m.owner != nil {
t.Fatal("source replacement retained input")
}
data, _ := json.Marshal(s.State())
if strings.Contains(string(data), "gamepad") || strings.Contains(string(data), "device") {
t.Fatal("baseline state gained extension fields")
}
m.Close()
if !pads.closed {
t.Fatal("Manager did not close gamepad backend")
}
}
func TestGamepadStopReleasesOnlyItsDeviceAndSlot(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 8), resets: make(chan struct{}, 8), focused: true}
pads := &recordedGamepads{capacity: 1}
m := &Manager{sink: sink, gamepads: pads, connections: map[endpointKey]*connection{}}
_, players := coPlaySession(t, m, true, true)
a, b := players[0], players[1]
for _, c := range players {
sendTestInput(m, c, inputEvent{Type: "request"})
}
report := gamepadReport{Buttons: 1}
sendTestInput(m, a, inputEvent{Type: "key", Code: "KeyA", Down: true})
sendTestInput(m, a, inputEvent{Type: "gamepad", Gamepad: &report})
first := a.pad.(*recordedGamepad)
sendTestInput(m, a, inputEvent{Type: "gamepad-reset"})
if first.closed || first.state != (gamepadReport{}) {
t.Fatal("focus reset retired the game-assigned device")
}
sendTestInput(m, a, inputEvent{Type: "gamepad-stop"})
if !first.closed || a.pad != nil || a.grant == "" || !a.keys["KeyA"] || b.grant == "" {
t.Fatal("device stop retained the device or retired keyboard authorization")
}
sendTestInput(m, b, inputEvent{Type: "gamepad", Gamepad: &report})
if b.pad == nil || b.padFailed {
t.Fatal("device stop did not free the backend slot for another participant")
}
sendTestInput(m, b, inputEvent{Type: "gamepad-stop"})
sendTestInput(m, a, inputEvent{Type: "gamepad", Gamepad: &report})
if a.pad == nil || a.pad == first || a.padFailed {
t.Fatal("reconnected device did not reuse its existing grant")
}
m.Close()
}
func TestCoPlayGamepadAdmissionAndFailure(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 32), resets: make(chan struct{}, 16), focused: true}
pads := &recordedGamepads{capacity: 1}
m := &Manager{sink: sink, gamepads: pads, connections: map[endpointKey]*connection{}}
s, players := coPlaySession(t, m, true, true, false)
if err := setTestPolicy(s, "ask", ""); err != nil {
t.Fatal(err)
}
a, b, legacy := players[0], players[1], players[2]
sendTestInput(m, a, inputEvent{Type: "request"})
if !a.requested || a.pad != nil {
t.Fatal("pending permission allocated a pad")
}
pads.openErr = errors.New("no driver slot")
if err := s.Decide(a.requestID, true); err != nil {
t.Fatal(err)
}
report := gamepadReport{Buttons: 1}
sendTestInput(m, a, inputEvent{Type: "gamepad", Gamepad: &report})
if a.grant == "" || !a.padFailed || a.pad != nil {
t.Fatal("pad allocation failure revoked ordinary permission")
}
pads.openErr = nil
sendTestInput(m, a, inputEvent{Type: "gamepad", Gamepad: &report})
if len(pads.devices) != 0 {
t.Fatal("failed grant retried gamepad allocation")
}
sendTestInput(m, a, inputEvent{Type: "release", Intent: a.intent})
sendTestInput(m, a, inputEvent{Type: "request"})
if err := s.Decide(a.requestID, true); err != nil {
t.Fatal(err)
}
sendTestInput(m, a, inputEvent{Type: "gamepad", Gamepad: &report})
if a.pad == nil || a.padFailed {
t.Fatal("fresh grant did not reset gamepad failure")
}
sendTestInput(m, b, inputEvent{Type: "request"})
if err := s.Decide(b.requestID, true); err != nil {
t.Fatal(err)
}
sendTestInput(m, b, inputEvent{Type: "gamepad", Gamepad: &report})
if b.grant == "" || !b.padFailed || len(pads.devices) != 1 {
t.Fatal("capacity failure revoked keyboard authorization")
}
sendTestInput(m, b, inputEvent{Type: "key", Code: "KeyA", Down: true})
<-sink.events
m.release()
sendTestInput(m, legacy, inputEvent{Type: "request"})
if err := s.Decide(legacy.requestID, true); err != nil {
t.Fatal(err)
}
sendTestInput(m, legacy, inputEvent{Type: "gamepad", Gamepad: &report})
if legacy.pad != nil || legacy.grant == "" {
t.Fatal("legacy input gained gamepad support or lost its baseline grant")
}
m.Revoke()
for _, pad := range pads.devices {
if !pad.closed || pad.state != (gamepadReport{}) {
t.Fatal("panic stop retained gamepad input")
}
}
}
type blockedGamepadCreation struct {
started chan struct{}
finish chan struct{}
pad *recordedGamepad
opens atomic.Int32
}
func (b *blockedGamepadCreation) Open() (gamepadDevice, error) {
b.opens.Add(1)
b.started <- struct{}{}
<-b.finish
return b.pad, nil
}
func (b *blockedGamepadCreation) Close() error { return nil }
func TestGamepadCreationDoesNotBlockCurrentInputOrRevocation(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 16), resets: make(chan struct{}, 16), focused: true}
backend := &blockedGamepadCreation{started: make(chan struct{}, 4), finish: make(chan struct{}), pad: &recordedGamepad{}}
m := &Manager{sink: sink, gamepads: backend, connections: map[endpointKey]*connection{}}
s, players := coPlaySession(t, m, true, true)
a, b := players[0], players[1]
for _, c := range players {
sendTestInput(m, c, inputEvent{Type: "request"})
}
existing := &recordedGamepad{}
a.pad = existing
report := gamepadReport{Buttons: 1}
push := func(c *connection) {
m.mu.Lock()
m.receiveGamepad(c, inputEvent{Type: "gamepad", Gamepad: &report})
m.mu.Unlock()
}
push(b)
select {
case <-backend.started:
case <-time.After(time.Second):
t.Fatal("creation did not start")
}
defer func() {
select {
case <-backend.finish:
default:
close(backend.finish)
}
}()
for range 32 {
push(b)
}
progress := make(chan struct{})
go func() {
push(a)
sendTestInput(m, a, inputEvent{Type: "key", Code: "KeyA", Down: true})
m.Revoke()
close(progress)
}()
select {
case <-progress:
case <-time.After(time.Second):
t.Fatal("enumeration blocked current pad, keyboard or control-stop")
}
if !existing.closed || existing.state != (gamepadReport{}) || a.grant != "" || b.grant != "" {
t.Fatal("control-stop retained current input")
}
sendTestInput(m, b, inputEvent{Type: "request"})
if err := s.Decide(b.requestID, true); err != nil {
t.Fatal(err)
}
push(b)
if backend.opens.Load() != 1 {
t.Fatal("full reports or a replacement grant started parallel creation")
}
close(backend.finish)
deadline := time.Now().Add(time.Second)
for {
m.mu.Lock()
opening := m.gamepadOpening
m.mu.Unlock()
if !opening {
break
}
if time.Now().After(deadline) {
t.Fatal("stale creation did not retire")
}
time.Sleep(time.Millisecond)
}
if !backend.pad.closed || b.pad != nil || b.grant == "" || b.padFailed {
t.Fatal("stale creation attached to or changed a replacement grant")
}
}
func TestGamepadStopDiscardsPendingCreationWithoutRetiringGrant(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 8), resets: make(chan struct{}, 8), focused: true}
backend := &blockedGamepadCreation{started: make(chan struct{}, 1), finish: make(chan struct{}), pad: &recordedGamepad{}}
m := &Manager{sink: sink, gamepads: backend, connections: map[endpointKey]*connection{}}
_, players := coPlaySession(t, m, true)
c := players[0]
sendTestInput(m, c, inputEvent{Type: "request"})
grant := c.grant
report := gamepadReport{Buttons: 1}
m.mu.Lock()
m.receiveGamepad(c, inputEvent{Type: "gamepad", Gamepad: &report})
m.mu.Unlock()
select {
case <-backend.started:
case <-time.After(time.Second):
t.Fatal("device enumeration did not start")
}
sendTestInput(m, c, inputEvent{Type: "gamepad-stop"})
close(backend.finish)
deadline := time.Now().Add(time.Second)
for {
m.mu.Lock()
opening := m.gamepadOpening
m.mu.Unlock()
if !opening {
break
}
if time.Now().After(deadline) {
t.Fatal("stopped enumeration did not finish")
}
time.Sleep(time.Millisecond)
}
if !backend.pad.closed || c.pad != nil || c.grant != grant || c.padFailed {
t.Fatal("late enumeration revived the stopped device or changed its keyboard grant")
}
// A subsequent full report can create a fresh device under the same grant.
pads := &recordedGamepads{}
m.gamepads = pads
sendTestInput(m, c, inputEvent{Type: "gamepad", Gamepad: &report})
if c.pad == nil || c.pad.(*recordedGamepad).state != report || c.grant != grant {
t.Fatal("reconnection could not create a fresh device")
}
m.Close()
}
func sendTestInput(m *Manager, c *connection, event inputEvent) {
if event.Type == "request" && event.Intent == "" {
event.Intent = strings.Repeat("f", 32)
}
if event.Grant == "" {
event.Grant = c.grant
}
data, _ := json.Marshal(event)
receiveTestInput(m, c, data)
if event.Type == "gamepad" {
// Unit reports model the next periodic full report after lazy creation;
// production deliberately drops the report that started enumeration.
deadline := time.Now().Add(time.Second)
for {
m.mu.Lock()
opening := m.gamepadOpening
m.mu.Unlock()
if !opening {
break
}
if time.Now().After(deadline) {
panic("gamepad creation did not finish")
}
time.Sleep(time.Millisecond)
}
receiveTestInput(m, c, data)
}
}
func TestCoPlaySharedKeyboardAndMouse(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 64), resets: make(chan struct{}, 16), focused: true}
m := &Manager{sink: sink, connections: map[endpointKey]*connection{}}
s, players := coPlaySession(t, m, true, true)
a, b := players[0], players[1]
for _, c := range players {
sendTestInput(m, c, inputEvent{Type: "request"})
}
if a.grant == "" || b.grant == "" || m.owner != s || len(s.State().Requests) != 2 {
t.Fatal("co-play did not admit both players")
}
for _, c := range players {
sendTestInput(m, c, inputEvent{Type: "key", Code: "KeyA", Down: true})
sendTestInput(m, c, inputEvent{Type: "button", Button: 0, Down: true})
sendTestInput(m, c, inputEvent{Type: "button", Button: 0, Down: true})
}
if len(sink.events) != 2 {
t.Fatal("shared held input was injected twice")
}
for len(sink.events) > 0 {
<-sink.events
}
for _, c := range players {
sendTestInput(m, c, inputEvent{Type: "key", Code: "KeyA", Down: true})
if len(sink.events) != 1 {
t.Fatal("an existing holder's keyboard repeat was suppressed")
}
if event := <-sink.events; event.Type != "key" || event.Code != "KeyA" || !event.Down {
t.Fatal("an existing holder's keyboard repeat was suppressed")
}
}
sendTestInput(m, a, inputEvent{Type: "key", Code: "KeyA"})
sendTestInput(m, a, inputEvent{Type: "button", Button: 0})
sendTestInput(m, b, inputEvent{Type: "text", Text: "hello"})
if len(sink.events) != 0 || len(sink.resets) != 0 {
t.Fatal("a player released another player's input or reset shared input through text")
}
for _, c := range players {
sendTestInput(m, c, inputEvent{Type: "move", X: .5, Y: .5})
}
sendTestInput(m, b, inputEvent{Type: "relative", DX: 10, DY: -4})
sendTestInput(m, a, inputEvent{Type: "wheel", Delta: 120})
if len(sink.events) != 4 {
t.Fatal("authorized players cannot share pointer movement and scrolling")
}
for len(sink.events) > 0 {
<-sink.events
}
sendTestInput(m, a, inputEvent{Type: "key", Code: "KeyW", Down: true})
sendTestInput(m, a, inputEvent{Type: "button", Button: 1, Down: true})
for len(sink.events) > 0 {
<-sink.events
}
if err := s.Decide(a.requestID, false); err != nil {
t.Fatal(err)
}
if len(sink.events) != 2 {
t.Fatal("personal revocation did not release only distinct held input")
}
for len(sink.events) > 0 {
event := <-sink.events
if event.Down || !(event.Type == "key" && event.Code == "KeyW" || event.Type == "button" && event.Button == 1) {
t.Fatal("personal revocation changed a sibling's input")
}
}
if b.grant == "" || !b.keys["KeyA"] || !b.buttons[0] || len(sink.resets) != 0 || s.mode != "room" {
t.Fatal("revocation disrupted another player")
}
sendTestInput(m, b, inputEvent{Type: "reset"})
if len(sink.events) != 2 {
t.Fatal("final holder reset missed a key or mouse button")
}
for len(sink.events) > 0 {
if (<-sink.events).Down {
t.Fatal("reset pressed input")
}
}
sendTestInput(m, b, inputEvent{Type: "key", Code: "KeyB", Down: true})
<-sink.events
m.Revoke()
if b.grant != "" || m.owner != nil || len(sink.resets) != 1 || s.mode != "ask" {
t.Fatal("Host stop left a player active")
}
}
func TestSimultaneousControlPreservesAuthorizationAndResetsForNewSource(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 64), resets: make(chan struct{}, 16), focused: true}
m := &Manager{sink: sink, gamepads: &recordedGamepads{}, connections: map[endpointKey]*connection{}}
s, players := coPlaySession(t, m, true, true)
if err := setTestPolicy(s, "password", "source-password"); err != nil {
t.Fatal(err)
}
if err := s.SetSimultaneous(false); err != nil {
t.Fatal(err)
}
for _, c := range players {
s.passwordRetry = time.Time{}
sendTestInput(m, c, inputEvent{Type: "request", Password: "source-password"})
}
if players[0].grant == "" || players[1].grant != "" {
t.Fatal("single control admitted multiple participants")
}
if state := s.State(); !state.CoPlay || state.Gamepad == nil || !*state.Gamepad || state.Requests[0].EndpointID == "" {
t.Fatal("single control hid extended capabilities or participation")
}
if err := s.SetSimultaneous(true); err != nil {
t.Fatal(err)
}
if players[0].grant != "" || len(s.State().Requests) != 0 || s.mode != "password" {
t.Fatal("setting change retained grants or changed authorization")
}
for _, c := range players {
s.passwordRetry = time.Time{}
sendTestInput(m, c, inputEvent{Type: "request", Password: "source-password"})
}
if players[0].grant == "" || players[1].grant == "" {
t.Fatal("setting change lost password or failed to admit both participants")
}
if err := setTestPolicy(s, "ask", ""); err != nil {
t.Fatal(err)
}
if !*s.State().Simultaneous {
t.Fatal("ordinary authorization update reset source concurrency")
}
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "next"}, nil)
change, err := s.BeginPolicy(t.Context(), "room", "", true)
if err != nil {
t.Fatal(err)
}
defer change.Close()
if err := change.Apply(); err != nil {
t.Fatal(err)
}
if *s.State().Simultaneous || !s.State().CoPlay {
t.Fatal("new source inherited concurrency or lost negotiated support")
}
if err := setTestPolicy(s, "ask", ""); err != nil {
t.Fatal(err)
}
for _, c := range players {
sendTestInput(m, c, inputEvent{Type: "request"})
}
if err := s.Decide(players[0].requestID, true); err != nil {
t.Fatal(err)
}
sendTestInput(m, players[0], inputEvent{Type: "key", Code: "KeyA", Down: true})
<-sink.events
if err := s.Decide(players[1].requestID, true); err != nil {
t.Fatal(err)
}
if players[0].grant != "" || players[1].grant == "" || m.owner != s || len(players[0].keys) != 0 {
t.Fatal("explicit Host approval did not hand over exclusive input")
}
other, otherPlayers := coPlaySession(t, m, true)
if err := setTestPolicy(other, "ask", ""); err != nil {
t.Fatal(err)
}
if err := other.SetSimultaneous(false); err != nil {
t.Fatal(err)
}
sendTestInput(m, otherPlayers[0], inputEvent{Type: "request"})
if err := other.Decide(otherPlayers[0].requestID, true); err == nil || players[1].grant == "" || m.owner != s {
t.Fatal("explicit approval displaced another source")
}
}
func TestCoPlayTextFollowsKeyboardGrants(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 32), resets: make(chan struct{}, 16), focused: true}
m := &Manager{sink: sink, gamepads: &recordedGamepads{}, connections: map[endpointKey]*connection{}}
s, players := coPlaySession(t, m, true, true)
a, b := players[0], players[1]
sendTestInput(m, a, inputEvent{Type: "request"})
sendTestInput(m, a, inputEvent{Type: "gamepad", Gamepad: &gamepadReport{Buttons: 1}})
sendTestInput(m, a, inputEvent{Type: "key", Code: "ControlLeft", Down: true})
<-sink.events
sendTestInput(m, a, inputEvent{Type: "text", Text: "hello"})
if (<-sink.events).Text != "hello" || len(a.keys) != 0 || len(sink.resets) != 1 || a.pad == nil {
t.Fatal("single participant text did not reset its own held keyboard input")
}
sendTestInput(m, b, inputEvent{Type: "request"})
sendTestInput(m, b, inputEvent{Type: "key", Code: "KeyW", Down: true})
<-sink.events
sendTestInput(m, a, inputEvent{Type: "text", Text: "blocked"})
if len(sink.events) != 0 || len(sink.resets) != 1 || !b.keys["KeyW"] {
t.Fatal("text interrupted another keyboard player")
}
if err := s.Decide(b.requestID, false); err != nil {
t.Fatal(err)
}
<-sink.events
sendTestInput(m, a, inputEvent{Type: "text", Text: "restored"})
if (<-sink.events).Text != "restored" || a.grant == "" || a.pad == nil {
t.Fatal("text did not resume after the other keyboard grant ended")
}
}
func TestCoPlayRetirementAndLegacyAdmission(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 64), resets: make(chan struct{}, 16), focused: true}
m := &Manager{sink: sink, connections: map[endpointKey]*connection{}}
s, players := coPlaySession(t, m, true, true, false)
a, b, legacy := players[0], players[1], players[2]
sendTestInput(m, legacy, inputEvent{Type: "request"})
sendTestInput(m, a, inputEvent{Type: "request"})
if legacy.grant == "" || a.grant != "" {
t.Fatal("legacy client was admitted without exclusive full control")
}
sendTestInput(m, legacy, inputEvent{Type: "release", Intent: legacy.intent})
for _, c := range []*connection{a, b} {
sendTestInput(m, c, inputEvent{Type: "request"})
}
sendTestInput(m, legacy, inputEvent{Type: "request"})
if a.grant == "" || b.grant == "" || legacy.grant != "" {
t.Fatal("legacy guest entered a concurrent-input session")
}
other, others := coPlaySession(t, m, true)
sendTestInput(m, others[0], inputEvent{Type: "request"})
if others[0].grant != "" || other.Decide(a.requestID, false) == nil {
t.Fatal("another native session acquired or changed the active desktop source")
}
for _, c := range []*connection{a, b} {
sendTestInput(m, c, inputEvent{Type: "key", Code: "KeyA", Down: true})
}
<-sink.events
revokeTestEdge(s, a.edgeID)
if a.grant != "" || b.grant == "" || len(sink.events) != 0 || m.owner != s {
t.Fatal("one route loss released another player's held key")
}
sink.focused = false
m.refreshActive()
m.refreshActive()
if !b.suspended || len(b.keys) != 0 || len(sink.resets) != 1 {
t.Fatal("shared-input source did not suspend once")
}
sink.focused = true
m.refreshActive()
if b.suspended || len(sink.events) != 0 {
t.Fatal("focus recovery replayed held keys")
}
sendTestInput(m, b, inputEvent{Type: "key", Code: "KeyB", Down: true})
<-sink.events
oldGrant := b.grant
s.Pause(true)
if b.grant != "" || len(sink.resets) != 2 {
t.Fatal("pause retained co-play input")
}
s.Pause(false)
sendTestInput(m, b, inputEvent{Type: "key", Code: "KeyC", Down: true, Grant: oldGrant})
if len(sink.events) != 0 {
t.Fatal("resume restored a stale grant")
}
sendTestInput(m, b, inputEvent{Type: "request"})
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "2"}, nil)
if b.grant != "" || m.owner != nil || s.State().CoPlay || s.State().Mode != "off" {
t.Fatal("source replacement inherited co-play authorization")
}
data, _ := json.Marshal(s.State())
if strings.Contains(string(data), "coPlay") || strings.Contains(string(data), "pointer") {
t.Fatal("default Host state added fields to the published baseline")
}
}
// Exercise the consent/retirement owner over real SCTP channels. No OS input
// is injected by this test; the platform acceptance uses a dedicated window.
func TestAttendedGrantLifecycle(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 20), resets: make(chan struct{}, 20), geometry: bounds{width: 1920, height: 1080}, focused: true}
m := &Manager{sink: sink, connections: map[endpointKey]*connection{}}
s := m.NewSession()
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "1"}, nil)
if err := setTestPolicy(s, "ask", ""); err != nil {
t.Fatal(err)
}
t.Cleanup(m.Close)
host, err := webrtc.NewPeerConnection(webrtc.Configuration{})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = host.Close() })
viewer, err := webrtc.NewPeerConnection(webrtc.Configuration{})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = viewer.Close() })
channels := make(chan *webrtc.DataChannel, 2)
type observedState struct {
peer, state string
capabilities []string
coPlay *bool
grant string
inputFailed *bool
}
states := make(chan observedState, 128)
bindings := map[string]protocol.RemoteInputPeer{}
ciphers := map[string]*inputCipher{}
epochs := map[string]string{}
for _, name := range []string{"first", "second"} {
id, key := make([]byte, 16), make([]byte, 32)
_, _ = rand.Read(id)
_, _ = rand.Read(key)
bindings[name] = protocol.RemoteInputPeer{PeerID: name + "-viewer", EndpointID: hex.EncodeToString(id), Secret: hex.EncodeToString(key)}
ciphers[name], _ = newInputCipher(bindings[name].Secret)
epochs[name] = bindings[name].EndpointID
}
if err := s.SetPeers([]protocol.RemoteInputPeer{bindings["first"], bindings["second"]}); err != nil {
t.Fatal(err)
}
viewer.OnDataChannel(func(c *webrtc.DataChannel) {
c.OnMessage(func(message webrtc.DataChannelMessage) {
var packet inputroute.Packet
if json.Unmarshal(message.Data, &packet) != nil || packet.ID != bindings[c.Label()].EndpointID {
return
}
bytes, err := base64.StdEncoding.DecodeString(packet.Data)
if err != nil || len(bytes) < 36 {
return
}
plain, err := ciphers[c.Label()].aead.Open(nil, bytes[8:20], bytes[20:], inputAAD(1, bytes[:8], packet.Epoch))
if err != nil {
return
}
var value struct {
State string `json:"state"`
Capabilities []string `json:"capabilities"`
CoPlay *bool `json:"coPlay"`
Grant string `json:"grant"`
InputFailed *bool `json:"inputFailed"`
}
if json.Unmarshal(plain, &value) == nil {
states <- observedState{c.Label(), value.State, value.Capabilities, value.CoPlay, value.Grant, value.InputFailed}
}
})
c.OnOpen(func() { channels <- c })
})
losses := map[string]func(){}
for _, id := range []string{"first", "second"} {
c, err := host.CreateDataChannel(id, nil)
if err != nil {
t.Fatal(err)
}
losses[id] = s.Attach(id, c)
}
offer, err := host.CreateOffer(nil)
if err != nil {
t.Fatal(err)
}
gathered := webrtc.GatheringCompletePromise(host)
if err = host.SetLocalDescription(offer); err != nil {
t.Fatal(err)
}
select {
case <-gathered:
case <-time.After(5 * time.Second):
t.Fatal("offer gathering timed out")
}
if err = viewer.SetRemoteDescription(*host.LocalDescription()); err != nil {
t.Fatal(err)
}
answer, err := viewer.CreateAnswer(nil)
if err != nil {
t.Fatal(err)
}
gathered = webrtc.GatheringCompletePromise(viewer)
if err = viewer.SetLocalDescription(answer); err != nil {
t.Fatal(err)
}
select {
case <-gathered:
case <-time.After(5 * time.Second):
t.Fatal("answer gathering timed out")
}
if err = host.SetRemoteDescription(*viewer.LocalDescription()); err != nil {
t.Fatal(err)
}
peers := map[string]*webrtc.DataChannel{}
for range 2 {
select {
case c := <-channels:
peers[c.Label()] = c
case <-time.After(5 * time.Second):
t.Fatal("channel did not open")
}
}
wait := func(check func() bool) {
t.Helper()
deadline := time.Now().Add(3 * time.Second)
for time.Now().Before(deadline) {
m.mu.Lock()
ok := check()
m.mu.Unlock()
if ok {
return
}
time.Sleep(5 * time.Millisecond)
}
t.Fatal("grant state did not settle")
}
send := func(peer string, event inputEvent) {
t.Helper()
cipher := ciphers[peer]
cipher.sent++
header := make([]byte, 20)
binary.BigEndian.PutUint64(header, cipher.sent)
_, _ = rand.Read(header[8:])
plain, _ := json.Marshal(event)
epoch := epochs[peer]
data := cipher.aead.Seal(header, header[8:], plain, inputAAD(0, header[:8], epoch))
packet, _ := json.Marshal(inputroute.Packet{ID: bindings[peer].EndpointID, Epoch: epoch, Data: base64.StdEncoding.EncodeToString(data)})
if err := peers[peer].SendText(string(packet)); err != nil {
t.Fatal(err)
}
}
request := func(peer string) *connection {
t.Helper()
intent := make([]byte, 16)
_, _ = rand.Read(intent)
send(peer, inputEvent{Type: "request", Intent: hex.EncodeToString(intent)})
var found *connection
wait(func() bool {
for _, c := range m.connections {
if c.edgeID == peer && c.requested {
found = c
return true
}
}
return false
})
return found
}
decide := func(c *connection, allow bool) string {
t.Helper()
if err := s.Decide(c.requestID, allow); err != nil {
t.Fatal(err)
}
m.mu.Lock()
defer m.mu.Unlock()
return c.grant
}
key := func(c *connection, grant string) {
receiveTestInput(m, c, []byte(`{"type":"key","code":"KeyA","down":true,"grant":"`+grant+`"}`))
}
<-s.Changes() // Drain display setup; the next notification must be a request.
first := request("first")
other := m.NewSession()
other.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "2"}, nil)
if err := other.SetPeers([]protocol.RemoteInputPeer{bindings["first"]}); err != nil {
t.Fatal("endpoint identity leaked across independent rooms", err)
}
if len(other.State().Requests) != 0 || other.Decide(first.requestID, true) == nil || other.Decide(first.requestID, false) == nil {
t.Fatal("another Host session can view or decide this share's request")
}
select {
case <-s.Changes():
views := s.State().Requests
if len(views) != 1 || views[0].PeerID != "first-viewer" || views[0].State != "pending" {
t.Fatal("request not reflected in its Host snapshot")
}
default:
t.Fatal("request did not notify its Host")
}
key(first, "")
if len(sink.events) != 0 {
t.Fatal("unapproved input accepted")
}
grant := decide(first, true)
if s.State().Requests[0].State != "active" {
t.Fatal("approval not reflected in Host snapshot")
}
if grant == "" {
t.Fatal("missing grant")
}
key(first, grant)
if len(sink.events) != 1 {
t.Fatal("approved input missing")
}
second := request("second")
grant2 := decide(second, true)
key(first, grant)
if len(sink.events) != 1 || len(sink.resets) != 1 {
t.Fatal("takeover did not retire old input")
}
key(second, grant2)
s.Pause(true)
key(second, grant2)
if len(sink.events) != 2 || len(sink.resets) != 2 {
t.Fatal("pause did not release input")
}
// Wait for the paused status before resuming; a ready message from the
// initial connection must not stand in for the actual resume notification.
stateDeadline := time.After(3 * time.Second)
waitState := func(want string) {
t.Helper()
for {
select {
case state := <-states:
if state.peer == "second" && state.state == want {
return
}
case <-stateDeadline:
t.Fatalf("missing viewer state %q", want)
}
}
}
waitState("unavailable")
s.Pause(false)
waitState("ready")
second = request("second")
grant2 = decide(second, true)
losses["second"]()
key(second, grant2)
if len(sink.events) != 2 || len(sink.resets) != 3 {
t.Fatal("disconnect kept a grant")
}
// ICE may recover on the same channel. It must accept a fresh request,
// without reviving the old grant or a pending approval from before loss.
second = request("second")
staleRequest := second.requestID
losses["second"]()
if s.Decide(staleRequest, true) == nil || len(s.State().Requests) != 0 {
t.Fatal("transport loss kept a pending approval")
}
second = request("second")
key(second, grant2)
if len(sink.events) != 2 {
t.Fatal("new request restored the disconnected grant")
}
decide(second, false)
first = request("first")
grant = decide(first, true)
m.Revoke()
key(first, grant)
if len(sink.events) != 2 || len(sink.resets) != 4 {
t.Fatal("local stop kept a grant")
}
first = request("first")
grant = decide(first, true)
s.SetTarget(nativecapture.CaptureTarget{}, nil)
key(first, grant)
if len(sink.events) != 2 || len(sink.resets) != 5 || s.available() {
t.Fatal("source replacement kept input authority")
}
nextDisplay := bounds{left: 1920, width: 1280, height: 720}
sink.geometry = nextDisplay
s.SetTarget(nativecapture.CaptureTarget{Kind: "window", SourceID: "3"}, nil)
if err := setTestPolicy(s, "ask", ""); err != nil {
t.Fatal(err)
}
first = request("first")
oldRequest, oldIntent := first.requestID, first.intent
receiveTestInput(m, first, []byte(`{"type":"release","intent":"`+oldIntent+`"}`))
first = request("first")
if s.Decide(oldRequest, true) == nil {
t.Fatal("late approval authorized a replacement request")
}
nextGrant := decide(first, true)
receiveTestInput(m, first, []byte(`{"type":"release","intent":"`+oldIntent+`"}`))
key(first, grant)
key(first, nextGrant)
if len(sink.events) != 3 || nextGrant == grant || sink.target != nextDisplay {
t.Fatal("replacement did not require fresh approval on the existing channel")
}
// A held key must be released when the Host leaves the shared window,
// even when the Viewer sends nothing. Focus recovery retains the grant.
m.mu.Lock()
sink.focused = false
m.refreshActive()
m.refreshActive()
m.mu.Unlock()
key(first, nextGrant)
if !first.suspended || s.State().Requests[0].State != "suspended" || len(sink.events) != 3 || len(sink.resets) != 6 {
t.Fatal("window focus loss did not suspend and release held input once")
}
sink.focused = true
sink.geometry = bounds{left: 100, top: 200, width: 640, height: 480}
key(first, nextGrant)
if first.suspended || len(sink.events) != 4 || sink.target != sink.geometry {
t.Fatal("window movement/focus recovery did not use the current target")
}
// Old strict readers get precisely the baseline until this exact Guest opts
// into the extension, including when another Guest has already opted in.
for len(states) > 0 {
<-states
}
waitReply := func(peer string, extended bool) observedState {
t.Helper()
deadline := time.After(3 * time.Second)
for {
select {
case state := <-states:
if state.peer == peer && (state.coPlay != nil) == extended {
return state
}
case <-deadline:
t.Fatal("input state reply missing")
}
}
}
send("first", inputEvent{Type: "sync"})
if state := waitReply("first", false); len(state.capabilities) != 0 {
t.Fatal("baseline sync added unnegotiated fields")
}
send("first", inputEvent{Type: "capabilities"})
if state := waitReply("first", true); *state.coPlay || len(state.capabilities) != 2 || state.capabilities[0] != "coPlay" || state.capabilities[1] != "inputFeedback" {
t.Fatal("extended Guest did not receive the explicit single-controller capability state")
}
send("second", inputEvent{Type: "sync"})
if state := waitReply("second", false); len(state.capabilities) != 0 {
t.Fatal("one Guest opted another Guest into the extension")
}
// The old capabilities command does not opt a strict reader into new keys.
m.mu.Lock()
sink.applyErr = errors.New("execution temporarily refused")
m.mu.Unlock()
send("first", inputEvent{Type: "move", X: .4, Y: .3, Grant: nextGrant})
wait(func() bool { return first.inputFailed })
if state := waitReply("first", true); state.inputFailed != nil || state.grant != nextGrant || state.state != "active" {
t.Fatal("legacy feedback changed JSON shape or retired its grant")
}
send("first", inputEvent{Type: "capabilities", InputFeedback: true})
if state := waitReply("first", true); state.inputFailed == nil || !*state.inputFailed || state.grant != nextGrant {
t.Fatal("explicit feedback opt-in did not report retained-grant failure")
}
m.mu.Lock()
sink.applyErr = nil
m.mu.Unlock()
send("first", inputEvent{Type: "move", X: .2, Y: .3, Grant: nextGrant})
wait(func() bool { return !first.inputFailed })
if state := waitReply("first", true); state.inputFailed != nil || state.grant != nextGrant || state.state != "active" {
t.Fatal("fresh input did not clear failure within the same grant")
}
// Replacing this endpoint's live epoch retires its opt-in along with its grant.
epochs["first"] = strings.Repeat("a", 32)
send("first", inputEvent{Type: "sync"})
if state := waitReply("first", false); state.inputFailed != nil || state.grant != "" {
t.Fatal("new epoch inherited grant or feedback fields")
}
first = request("first")
nextGrant = decide(first, true)
// Consume the active baseline reply before checking a later failure reply.
for state := waitReply("first", false); state.state != "active"; state = waitReply("first", false) {
}
m.mu.Lock()
sink.applyErr = errors.New("new epoch execution refused")
m.mu.Unlock()
send("first", inputEvent{Type: "move", X: .4, Y: .3, Grant: nextGrant})
wait(func() bool { return first.inputFailed })
if state := waitReply("first", false); state.inputFailed != nil || state.grant != nextGrant || state.state != "active" {
t.Fatal("new legacy epoch received an unnegotiated feedback field")
}
m.mu.Lock()
sink.applyErr = nil
m.mu.Unlock()
beforeCloseEvents, beforeCloseResets := len(sink.events), len(sink.resets)
s.Close()
key(first, nextGrant)
if len(sink.events) != beforeCloseEvents || len(sink.resets) != beforeCloseResets+1 || len(s.State().Requests) != 0 || s.Decide(first.requestID, true) == nil {
t.Fatal("source retirement kept a grant")
}
}
func TestLateOldEpochCannotHideRelayedGrantFromBranchLoss(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 8), resets: make(chan struct{}, 8), focused: true}
m := &Manager{sink: sink, connections: map[endpointKey]*connection{}}
s := m.NewSession()
t.Cleanup(s.Close)
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "1"}, nil)
if err := setTestPolicy(s, "ask", ""); err != nil {
t.Fatal(err)
}
peer := protocol.RemoteInputPeer{PeerID: "viewer-route-test", EndpointID: strings.Repeat("a", 32), Secret: strings.Repeat("b", 64)}
if err := s.SetPeers([]protocol.RemoteInputPeer{peer}); err != nil {
t.Fatal(err)
}
observed := make(chan inputroute.Packet, 10)
s.route.Close()
s.route = inputroute.New(func(edge string, p inputroute.Packet, current func() bool) {
s.receivePacket(edge, p, current)
observed <- p
})
rootChannel, relayUp := inputChannelPair(t)
s.Attach("sfu-root", rootChannel)
relay := inputroute.New(nil)
t.Cleanup(relay.Close)
relay.AttachUp(relayUp)
viewer, branch := inputChannelPair(t)
ready := make(chan struct{}, 10)
viewer.OnMessage(func(message webrtc.DataChannelMessage) {
var p inputroute.Packet
if json.Unmarshal(message.Data, &p) == nil && p.Ready != nil && *p.Ready {
ready <- struct{}{}
}
})
loseBranch := relay.AttachDown("shared-branch", branch)
relay.SetUpAvailable(true)
select {
case <-ready:
case <-time.After(3 * time.Second):
t.Fatal("relay not ready")
}
cipher, _ := newInputCipher(peer.Secret)
encode := func(seq uint64, epoch string, event inputEvent) inputroute.Packet {
header := make([]byte, 20)
binary.BigEndian.PutUint64(header, seq)
_, _ = rand.Read(header[8:])
plain, _ := json.Marshal(event)
data := cipher.aead.Seal(header, header[8:], plain, inputAAD(0, header[:8], epoch))
return inputroute.Packet{ID: peer.EndpointID, Epoch: epoch, Data: base64.StdEncoding.EncodeToString(data)}
}
sendPacket := func(p inputroute.Packet) {
t.Helper()
data, _ := json.Marshal(p)
if err := viewer.SendText(string(data)); err != nil {
t.Fatal(err)
}
deadline := time.After(3 * time.Second)
for {
select {
case got := <-observed:
if got == p {
return
}
case <-deadline:
t.Fatal("packet did not reach actual manager")
}
}
}
approve := func() string {
t.Helper()
views := s.State().Requests
if len(views) != 1 || views[0].State != "pending" {
t.Fatalf("request state: %+v", views)
}
if err := s.Decide(views[0].ID, true); err != nil {
t.Fatal(err)
}
m.mu.Lock()
defer m.mu.Unlock()
return m.connections[endpointKey{s, peer.EndpointID}].grant
}
oldEpoch, newEpoch := strings.Repeat("c", 32), strings.Repeat("d", 32)
sendPacket(encode(1, oldEpoch, inputEvent{Type: "request", Intent: oldEpoch}))
oldGrant := approve()
// Packet 2 was sent on the old longer branch before the route migrated.
// The new shorter path overtakes it. Its lower sequence must be rejected.
late := encode(2, oldEpoch, inputEvent{Type: "key", Code: "KeyA", Down: true, Grant: oldGrant})
sendPacket(encode(3, newEpoch, inputEvent{Type: "request", Intent: newEpoch}))
newGrant := approve()
sendPacket(encode(4, newEpoch, inputEvent{Type: "key", Code: "KeyW", Down: true, Grant: newGrant}))
sendPacket(late)
m.mu.Lock()
current := m.connections[endpointKey{s, peer.EndpointID}]
if current.grant != newGrant || current.keys["KeyA"] || !current.keys["KeyW"] {
m.mu.Unlock()
t.Fatal("late old packet changed authority")
}
m.mu.Unlock()
// The shared upstream branch then disconnects while the root SFU leg stays up.
loseBranch()
// On recovery, a sync is ordered behind all branch retirement packets. It
// may report current availability but cannot restore the previous grant.
sendPacket(encode(5, newEpoch, inputEvent{Type: "sync"}))
m.mu.Lock()
defer m.mu.Unlock()
if current.grant != "" || current.keys["KeyW"] {
t.Fatal("branch loss retained current grant and held key after a late old epoch")
}
}
func waitInputChannel(t *testing.T, label string, ready func() bool) {
t.Helper()
deadline := time.Now().Add(5 * time.Second)
for time.Now().Before(deadline) {
if ready() {
return
}
time.Sleep(5 * time.Millisecond)
}
t.Fatal(label)
}
func inputChannelPair(t *testing.T) (*webrtc.DataChannel, *webrtc.DataChannel) {
t.Helper()
settings := webrtc.SettingEngine{}
settings.SetIncludeLoopbackCandidate(true)
settings.SetNetworkTypes([]webrtc.NetworkType{webrtc.NetworkTypeUDP4})
api := webrtc.NewAPI(webrtc.WithSettingEngine(settings))
a, err := api.NewPeerConnection(webrtc.Configuration{})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = a.Close() })
b, err := api.NewPeerConnection(webrtc.Configuration{})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = b.Close() })
remote := make(chan *webrtc.DataChannel, 1)
b.OnDataChannel(func(c *webrtc.DataChannel) { remote <- c })
local, err := a.CreateDataChannel(inputroute.Label, nil)
if err != nil {
t.Fatal(err)
}
offer, err := a.CreateOffer(nil)
if err != nil {
t.Fatal(err)
}
gather := webrtc.GatheringCompletePromise(a)
if err = a.SetLocalDescription(offer); err != nil {
t.Fatal(err)
}
select {
case <-gather:
case <-time.After(5 * time.Second):
t.Fatal("offer gather")
}
if err = b.SetRemoteDescription(*a.LocalDescription()); err != nil {
t.Fatal(err)
}
answer, err := b.CreateAnswer(nil)
if err != nil {
t.Fatal(err)
}
gather = webrtc.GatheringCompletePromise(b)
if err = b.SetLocalDescription(answer); err != nil {
t.Fatal(err)
}
select {
case <-gather:
case <-time.After(5 * time.Second):
t.Fatal("answer gather")
}
if err = a.SetRemoteDescription(*b.LocalDescription()); err != nil {
t.Fatal(err)
}
var other *webrtc.DataChannel
select {
case other = <-remote:
case <-time.After(5 * time.Second):
t.Fatal("remote data channel")
}
waitInputChannel(t, "SCTP opens", func() bool {
return local.ReadyState() == webrtc.DataChannelStateOpen && other.ReadyState() == webrtc.DataChannelStateOpen
})
return local, other
}
func TestInputRetirementOrdersAlreadyReadPackets(t *testing.T) {
for _, retired := range []string{"channel", "ice", "explicit-close"} {
t.Run(retired, func(t *testing.T) {
sink := &recordedInput{events: make(chan inputEvent, 8), resets: make(chan struct{}, 8), focused: true}
m := &Manager{sink: sink, connections: map[endpointKey]*connection{}}
s := m.NewSession()
t.Cleanup(s.Close)
s.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "1"}, nil)
if err := setTestPolicy(s, "room", ""); err != nil {
t.Fatal(err)
}
peer := protocol.RemoteInputPeer{PeerID: "viewer-route-test", EndpointID: strings.Repeat("a", 32), Secret: strings.Repeat("b", 64)}
if err := s.SetPeers([]protocol.RemoteInputPeer{peer}); err != nil {
t.Fatal(err)
}
var arm atomic.Bool
entered, resume := make(chan struct{}), make(chan struct{})
resumed := false
defer func() {
if !resumed {
close(resume)
}
}()
observed := make(chan inputroute.Packet, 8)
s.route.Close()
s.route = inputroute.New(func(edge string, p inputroute.Packet, current func() bool) {
// This is the production handoff after Relay unlocks. Retirement
// must invalidate the captured delivery before Manager accepts it.
if (p.Data != "" || p.Closed) && arm.Swap(false) {
close(entered)
<-resume
}
s.receivePacket(edge, p, current)
observed <- p
})
viewer, root := inputChannelPair(t)
loseInput := s.Attach("root-edge", root)
cipher, _ := newInputCipher(peer.Secret)
epoch := strings.Repeat("c", 32)
send := func(seq uint64, event inputEvent) {
t.Helper()
header := make([]byte, 20)
binary.BigEndian.PutUint64(header, seq)
_, _ = rand.Read(header[8:])
plain, _ := json.Marshal(event)
data := cipher.aead.Seal(header, header[8:], plain, inputAAD(0, header[:8], epoch))
packet, _ := json.Marshal(inputroute.Packet{ID: peer.EndpointID, Epoch: epoch, Data: base64.StdEncoding.EncodeToString(data)})
if err := viewer.SendText(string(packet)); err != nil {
t.Fatal(err)
}
}
waitData := func() {
t.Helper()
deadline := time.After(3 * time.Second)
for {
select {
case p := <-observed:
if p.Data != "" {
return
}
case <-deadline:
t.Fatal("input did not reach Manager")
}
}
}
initial := inputEvent{Type: "sync"}
if retired == "explicit-close" {
initial = inputEvent{Type: "request", Intent: strings.Repeat("d", 32)}
}
send(1, initial)
waitData()
arm.Store(true)
if retired == "explicit-close" {
if len(s.State().Requests) != 1 {
t.Fatal("request was not approved")
}
data, _ := json.Marshal(inputroute.Packet{ID: peer.EndpointID, Epoch: epoch, Closed: true})
if err := viewer.SendText(string(data)); err != nil {
t.Fatal(err)
}
} else {
send(2, inputEvent{Type: "request", Intent: strings.Repeat("d", 32)})
}
select {
case <-entered:
case <-time.After(3 * time.Second):
t.Fatal("request was not read")
}
if retired != "ice" {
if err := root.Close(); err != nil {
t.Fatal(err)
}
} else {
loseInput()
}
close(resume)
resumed = true
if retired == "explicit-close" {
select {
case <-observed:
case <-time.After(3 * time.Second):
t.Fatal("explicit retirement did not reach Manager")
}
} else {
waitData()
}
if len(s.State().Requests) != 0 {
t.Fatal("already-read packet retained or recreated authorization after retirement")
}
if retired == "ice" {
send(3, inputEvent{Type: "request", Intent: strings.Repeat("e", 32)})
waitData()
views := s.State().Requests
if len(views) != 1 || views[0].State != "active" {
t.Fatalf("fresh request on recovered channel: %+v", views)
}
}
})
}
}