mirror of
https://github.com/netbirdio/netbird.git
synced 2026-09-22 22:59:09 +02:00
84 lines
2.1 KiB
Go
84 lines
2.1 KiB
Go
//go:build windows
|
|
|
|
package sleep
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// registerFake inserts a detector into the registry without touching the OS,
|
|
// so dispatch routing can be exercised in isolation. It returns the handle and
|
|
// a cleanup that removes the entry.
|
|
func registerFake(t *testing.T, cb func(EventType)) (int, func()) {
|
|
t.Helper()
|
|
|
|
registryMu.Lock()
|
|
nextHandle++
|
|
handle := nextHandle
|
|
d := &Detector{callback: cb, done: make(chan struct{}), handle: handle}
|
|
registry[handle] = d
|
|
registryMu.Unlock()
|
|
|
|
return handle, func() {
|
|
registryMu.Lock()
|
|
delete(registry, handle)
|
|
registryMu.Unlock()
|
|
}
|
|
}
|
|
|
|
func TestPowerCallback_MapsMessageTypes(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
msgType uintptr
|
|
want EventType
|
|
fires bool
|
|
}{
|
|
{"suspend", pbtAPMSuspend, EventTypeSleep, true},
|
|
{"resume automatic", pbtAPMResumeAutomatic, EventTypeWakeUp, true},
|
|
{"resume suspend", pbtAPMResumeSuspend, EventTypeWakeUp, true},
|
|
{"unknown", 0x9999, EventTypeUnknown, false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := make(chan EventType, 1)
|
|
handle, cleanup := registerFake(t, func(e EventType) { got <- e })
|
|
defer cleanup()
|
|
|
|
ret := powerCallback(uintptr(handle), tt.msgType, 0)
|
|
require.Equal(t, uintptr(0), ret, "callback must return ERROR_SUCCESS")
|
|
|
|
if !tt.fires {
|
|
assert.Empty(t, got, "no event should fire for unhandled message type")
|
|
return
|
|
}
|
|
select {
|
|
case e := <-got:
|
|
assert.Equal(t, tt.want, e, "mapped event type should match")
|
|
default:
|
|
t.Fatal("expected callback to fire")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDispatchEvent_UnknownHandleNoPanic(t *testing.T) {
|
|
require.NotPanics(t, func() {
|
|
dispatchEvent(-1, EventTypeSleep)
|
|
}, "dispatch for an unregistered handle must be a no-op")
|
|
}
|
|
|
|
func TestTriggerCallback_SkipsAfterDone(t *testing.T) {
|
|
done := make(chan struct{})
|
|
close(done)
|
|
|
|
fired := false
|
|
d := &Detector{}
|
|
d.triggerCallback(EventTypeSleep, func(EventType) { fired = true }, done)
|
|
|
|
assert.False(t, fired, "callback must not run once the detector is done")
|
|
}
|