From ab72c8eb852c0041d59f5aa0432020760ad59d20 Mon Sep 17 00:00:00 2001 From: yetone Date: Fri, 9 Oct 2026 23:07:41 +0800 Subject: [PATCH] gui: TestCoveredWindowStaysUp hides magpie and checks the window in one step, so the activation its open asked for can't unhide magpie in between (macos-latest, CI run 37942751214) Cause: on macos-latest the helper exited 1 with "window up: timed out waiting until magpie is hidden" (6.06 s: the whole 5 s wait). It passed on 3cd0b5f7's own run and the ten green runs after it, so it is a flake, not a missing window server: the open and covered steps before it passed on the same machine. Opening the window (openMain -> showHere -> Focus) asks the Mac to activate magpie, which it does through the window server and the run loop, not at once. On a loaded CI machine that activation can still be pending when the test hides magpie a moment later; it lands right after the hide and unhides magpie, which puts the window back, so every poll found it open. NSApp hide: itself is synchronous here (hidden with no window ordered in, in the same main-thread block), active or not, and under full CPU load. That the CI log has no line between is inferred from this: the only thing that puts a hidden app's windows back is unhiding it, and the helper's only activation is the open's. Change: the test's hide step hides magpie and reads whether the window counts as up in one block on the main thread, and hides again when it finds magpie shown again. No production code changes: a user can't hide magpie with Command-H before it is active. Not skipped: the test needs nothing CI lacks. Run: - The old step with a late activation injected (queued from another goroutine while the hide block runs, not committed): FAIL 3 of 3, "window up: timed out waiting until magpie is hidden" in 5.8-6.3 s, the CI failure. The new step with the same injection: ok, 3 of 3. - Guarantee still checked: windowUp with its "open as magpie was hidden" clause removed fails the new test, "hidden with magpie: the window counts as up=false, want true". - go test -count=10 -run TestCoveredWindowStaysUp ./internal/gui: ok. Before the change, load alone didn't reproduce it here: three copies at a time, 15 runs, with a busy loop on every core, all passed. - gofmt -l: nothing. go vet ./internal/gui (darwin), GOOS=linux and GOOS=windows go vet -tags nogui ./internal/gui, GOOS=windows go vet ./internal/gui: clean. go test ./internal/gui (darwin, under a temp HOME with pinned caches): ok. --- internal/gui/window_up_darwin_test.go | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/internal/gui/window_up_darwin_test.go b/internal/gui/window_up_darwin_test.go index 58c14368..20d5feb8 100644 --- a/internal/gui/window_up_darwin_test.go +++ b/internal/gui/window_up_darwin_test.go @@ -85,10 +85,22 @@ func init() { expect("covered", true) application.InvokeSync(func() { cover.Close() }) - // hidden with magpie, as by Command-H - application.InvokeSync(app.Hide) - waitFor("magpie is hidden", func() bool { return !windowOpen(h.main) }) - expect("hidden with magpie", true) + // hidden with magpie, as by Command-H. Opening asked the Mac to + // activate magpie (Focus), and on a loaded CI machine that + // activation can land after the hide, which unhides magpie and + // shows the window again: the hide and the check are one step on + // the main thread, and a hide undone that way is done again. + var hiddenUp bool + waitFor("magpie is hidden", func() bool { + if windowOpen(h.main) { + app.Hide() + } + hiddenUp = kept() + return !windowOpen(h.main) + }) + if !hiddenUp { + fail("hidden with magpie: the window counts as up=false, want true") + } application.InvokeSync(app.Show) waitFor("magpie is shown again", func() bool { return windowOpen(h.main) })