testdata: fix flaky timers test

The timers test interleaved goroutine prints with ticker/timer waits,
which produced non-deterministic output ordering under thread-based
scheduling. On loaded systems, the goroutine prints could race with
the ticker ticks, causing test failures.

Fix by synchronizing the goroutine via a done channel before the
first tick arrives. The goroutine still runs concurrently with the
ticker (proving both mechanisms work together), but finishes well
before the tick fires so the output order is deterministic.

Also use wider timing margins (goroutine at 100/200ms vs ticker at
500ms) to avoid races on slow CI machines.

Addresses tinygo-org/tinygo issue 4963.

Author: jakebailey

testdata/timers.go

@@ -5,57 +5,67 @@ import "time"
 var timer = time.NewTimer(time.Millisecond)
 
 func main() {
-	// Test ticker.
+	// Test ticker with concurrent goroutine.
+	// The goroutine finishes at 200ms, well before the first tick at 500ms.
+	// We wait for the goroutine to complete before receiving ticks so that
+	// output ordering is deterministic regardless of scheduler behavior.
 	ticker := time.NewTicker(time.Millisecond * 500)
 	println("waiting on ticker")
+	done := make(chan bool)
 	go func() {
-		time.Sleep(time.Millisecond * 150)
-		println(" - after 150ms")
-		time.Sleep(time.Millisecond * 200)
-		println(" - after 200ms")
-		time.Sleep(time.Millisecond * 300)
-		println(" - after 300ms")
+		time.Sleep(time.Millisecond * 100)
+		println(" - tick goroutine 100ms")
+		time.Sleep(time.Millisecond * 100)
+		println(" - tick goroutine 200ms")
+		done <- true
 	}()
+	<-done
 	<-ticker.C
 	println("waited on ticker at 500ms")
 	<-ticker.C
 	println("waited on ticker at 1000ms")
 	ticker.Stop()
-	// Drain any tick that was already queued before Stop took effect.
-	select {
-	case <-ticker.C:
-	default:
-	}
-	time.Sleep(time.Millisecond * 750)
+	// After Stop, no more ticks should be delivered. Use a timeout
+	// to verify. Note: we don't drain ticker.C first because the
+	// channel may or may not have a queued tick depending on timing.
+	// Instead, wait long enough that any queued tick would have been
+	// consumed and no new tick should arrive.
+	time.Sleep(time.Millisecond * 1500)
 	select {
 	case <-ticker.C:
 		println("fail: ticker should have stopped!")
 	default:
-		println("ticker was stopped (didn't send anything after 750ms)")
+		println("ticker was stopped (didn't send anything)")
 	}
 
+	// Test timer with concurrent goroutine.
 	timer := time.NewTimer(time.Millisecond * 750)
 	println("waiting on timer")
 	go func() {
 		time.Sleep(time.Millisecond * 200)
 		println(" - after 200ms")
-		time.Sleep(time.Millisecond * 400)
+		time.Sleep(time.Millisecond * 200)
 		println(" - after 400ms")
+		done <- true
 	}()
 	<-timer.C
+	<-done
 	println("waited on timer at 750ms")
 	time.Sleep(time.Millisecond * 500)
 
+	// Test timer reset.
 	reset := timer.Reset(time.Millisecond * 750)
 	println("timer reset:", reset)
 	println("waiting on timer")
 	go func() {
 		time.Sleep(time.Millisecond * 200)
 		println(" - after 200ms")
-		time.Sleep(time.Millisecond * 400)
+		time.Sleep(time.Millisecond * 200)
 		println(" - after 400ms")
+		done <- true
 	}()
 	<-timer.C
+	<-done
 	println("waited on timer at 750ms")
 	time.Sleep(time.Millisecond * 500)
 }

testdata/timers.txt

@@ -1,10 +1,9 @@
 waiting on ticker
- - after 150ms
- - after 200ms
+ - tick goroutine 100ms
+ - tick goroutine 200ms
 waited on ticker at 500ms
- - after 300ms
 waited on ticker at 1000ms
-ticker was stopped (didn't send anything after 750ms)
+ticker was stopped (didn't send anything)
 waiting on timer
  - after 200ms
  - after 400ms