test(daemon): use generated clock mocks for coordinator

commit: 4d15883de381328bfc39d8cd5ad24c97b18bf469
author: brice · 3mo ago · 2026-07-11 17:47 UTC
parent: 3398032
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

2 files · +79 -44

M internal/usecase/daemon/render_coordinator_test.go +76 -41


@@ -9,20 +9,72 @@ import (
9	9		"testing"
10	10		"time"
11	11
	12	+	"github.com/stretchr/testify/mock"
12	13		"github.com/stretchr/testify/require"
13	14
14	15		"github.com/bnema/vev/internal/domain"
15	16		"github.com/bnema/vev/internal/ports"
	17	+	portsmocks "github.com/bnema/vev/internal/ports/mocks"
16	18		"github.com/bnema/vev/internal/usecase/keys"
17	19		"github.com/bnema/vev/internal/usecase/layout"
18	20		)
19	21
20	22		// --- coordinator harness ------------------------------------------------------
21	23
22		-	// coordinatorHarness wires one coordinator to a fake clock and recording
23		-	// hooks. Every assertion is channel- or counter-based; nothing sleeps.
	24	+	// coordinatorMockClock uses generated mocks while retaining deterministic timer
	25	+	// channels and recorded deadlines for coordinator scheduling assertions.
	26	+	type coordinatorMockClock struct {
	27	+	clock *portsmocks.MockClock
	28	+	timers chan *coordinatorMockTimer
	29	+	inert bool
	30	+	}
	31	+
	32	+	type coordinatorMockTimer struct {
	33	+	mock *portsmocks.MockTimer
	34	+	ch chan time.Time
	35	+	duration time.Duration
	36	+	}
	37	+
	38	+	func newCoordinatorMockClock(t testing.T, capacity int) coordinatorMockClock {
	39	+	t.Helper()
	40	+	clk := &coordinatorMockClock{
	41	+	clock: portsmocks.NewMockClock(t),
	42	+	timers: make(chan *coordinatorMockTimer, capacity),
	43	+	}
	44	+	clk.clock.EXPECT().Now().Return(time.Time{}).Maybe()
	45	+	clk.clock.EXPECT().NewTimer(mock.MatchedBy(func(d time.Duration) bool {
	46	+	return d == urgentRenderDeadline \|\|
	47	+	(d >= minOutputRenderDeadline && d <= maxOutputRenderDeadline) \|\|
	48	+	d == maxSyncUpdateDuration
	49	+	})).RunAndReturn(func(d time.Duration) ports.Timer {
	50	+	timer := &coordinatorMockTimer{
	51	+	mock: portsmocks.NewMockTimer(t),
	52	+	duration: d,
	53	+	}
	54	+	if !clk.inert {
	55	+	timer.ch = make(chan time.Time, 1)
	56	+	}
	57	+	// A normal deadline reads C both in its worker and in the inert-clock
	58	+	// guard; a watchdog reads it in its worker. The generated expectation
	59	+	// makes every channel access observable without a hand-written Timer.
	60	+	timer.mock.EXPECT().C().Maybe().Return((<-chan time.Time)(timer.ch))
	61	+	timer.mock.EXPECT().Stop().Maybe().Return(true)
	62	+	clk.timers <- timer
	63	+	return timer.mock
	64	+	}).Maybe()
	65	+	return clk
	66	+	}
	67	+
	68	+	func newInertCoordinatorMockClock(t testing.T, capacity int) coordinatorMockClock {
	69	+	clk := newCoordinatorMockClock(t, capacity)
	70	+	clk.inert = true
	71	+	return clk
	72	+	}
	73	+
	74	+	// coordinatorHarness wires one coordinator to generated clock/timer mocks and
	75	+	// recording hooks. Every assertion is channel- or counter-based; nothing sleeps.
24	76		type coordinatorHarness struct {
25		-	clk *signalClock
	77	+	clk *coordinatorMockClock
26	78		wakes chan renderWake
27	79		previews chan renderWake
28	80		ackReady atomic.Bool

@@ -33,13 +85,13 @@ type coordinatorHarness struct {
33	85		func newCoordinatorHarness(t testing.T) coordinatorHarness {
34	86		t.Helper()
35	87		h := &coordinatorHarness{
36		-	clk: &signalClock{timers: make(chan *signalTimer, 16)},
	88	+	clk: newCoordinatorMockClock(t, 16),
37	89		wakes: make(chan renderWake, 16),
38	90		previews: make(chan renderWake, 16),
39	91		}
40	92		h.ackReady.Store(true)
41	93		h.rc = newRenderCoordinator(renderCoordinatorOptions{
42		-	clock: h.clk,
	94	+	clock: h.clk.clock,
43	95		wake: func(w renderWake) { h.wakes <- w },
44	96		ackReady: func() bool { return h.ackReady.Load() },
45	97		syncActive: func() bool { return h.syncActive.Load() },

@@ -50,9 +102,9 @@ func newCoordinatorHarness(t testing.T) coordinatorHarness {
50	102		// armedTimers drains every deadline armed so far. Arming happens
51	103		// synchronously inside the coordinator call, so a non-blocking drain is
52	104		// deterministic.
53		-	func (h coordinatorHarness) armedTimers(t testing.T) []*signalTimer {
	105	+	func (h coordinatorHarness) armedTimers(t testing.T) []*coordinatorMockTimer {
54	106		t.Helper()
55		-	var timers []*signalTimer
	107	+	var timers []*coordinatorMockTimer
56	108		for {
57	109		select {
58	110		case tm := <-h.clk.timers:

@@ -112,7 +164,7 @@ func requireNoInvalidation(t *testing.T, ch chan renderInvalidation) {
112	164		}
113	165		}
114	166
115		-	func awaitScheduledTimer(t testing.T, clk signalClock) *signalTimer {
	167	+	func awaitCoordinatorScheduledTimer(t testing.T, clk coordinatorMockClock) *coordinatorMockTimer {
116	168		t.Helper()
117	169		select {
118	170		case tm := <-clk.timers:

@@ -639,10 +691,10 @@ func TestProducerInvalidations(t *testing.T) {
639	691		file: "render.go",
640	692		name: "retained resize dispatch",
641	693		run: func(t testing.T, d Daemon, sess session, ac attachedClient) {
642		-	clk := &signalClock{timers: make(chan *signalTimer, 2)}
643		-	d.clock = clk
	694	+	clk := newCoordinatorMockClock(t, 2)
	695	+	d.clock = clk.clock
644	696		d.resize(sess, ac, domain.Size{Cols: 100, Rows: 26})
645		-	awaitScheduledTimer(t, clk).ch <- time.Time{}
	697	+	awaitCoordinatorScheduledTimer(t, clk).ch <- time.Time{}
646	698		},
647	699		},
648	700		{

@@ -747,23 +799,6 @@ func TestStartPaneGoroutinesAccountsForOneReader(t *testing.T) {
747	799		}
748	800		}
749	801
750		-	// inertTimer deliberately has a nil C channel. It verifies coordinator
751		-	// lifecycle paths do not strand workers behind fake clocks that never fire.
752		-	type inertTimer struct{ stopped atomic.Bool }
753		-
754		-	func (t *inertTimer) C() <-chan time.Time { return nil }
755		-	func (t *inertTimer) Reset(time.Duration) bool { return false }
756		-	func (t *inertTimer) Stop() bool { t.stopped.Store(true); return true }
757		-
758		-	type inertClock struct{ timers chan *inertTimer }
759		-
760		-	func (c *inertClock) Now() time.Time { return time.Time{} }
761		-	func (c *inertClock) NewTimer(time.Duration) ports.Timer {
762		-	t := &inertTimer{}
763		-	c.timers <- t
764		-	return t
765		-	}
766		-
767	802		func requireWorkerExit(t *testing.T, done <-chan struct{}) {
768	803		t.Helper()
769	804		for range 4096 {

@@ -788,8 +823,8 @@ func TestRenderCoordinatorStopsInertTimerWorkers(t *testing.T) {
788	823		}
789	824		for _, tc := range lifecycle {
790	825		t.Run(tc.name, func(t *testing.T) {
791		-	clk := &inertClock{timers: make(chan *inertTimer, 2)}
792		-	rc := newRenderCoordinator(renderCoordinatorOptions{clock: clk})
	826	+	clk := newInertCoordinatorMockClock(t, 2)
	827	+	rc := newRenderCoordinator(renderCoordinatorOptions{clock: clk.clock})
793	828		ac := &attachedClient{}
794	829		rc.attach(ac)
795	830		rc.invalidate(renderInvalidation{class: invalidateOutput})

@@ -798,12 +833,12 @@ func TestRenderCoordinatorStopsInertTimerWorkers(t *testing.T) {
798	833		normalDone := rc.normalWorkerDone
799	834		rc.mu.Unlock()
800	835		tc.end(rc, ac)
801		-	require.True(t, normal.stopped.Load(), "normal timer must be stopped")
	836	+	normal.mock.AssertNumberOfCalls(t, "Stop", 1)
802	837		requireWorkerExit(t, normalDone)
803	838
804	839		// Use a fresh coordinator because detach/teardown intentionally makes
805	840		// an attachment ineligible for a new synchronized batch.
806		-	rc = newRenderCoordinator(renderCoordinatorOptions{clock: clk})
	841	+	rc = newRenderCoordinator(renderCoordinatorOptions{clock: clk.clock})
807	842		rc.attach(ac)
808	843		rc.noteSyncBegin(1)
809	844		syncTimer := <-clk.timers

@@ -811,23 +846,23 @@ func TestRenderCoordinatorStopsInertTimerWorkers(t *testing.T) {
811	846		syncDone := rc.syncWorkerDone
812	847		rc.mu.Unlock()
813	848		tc.end(rc, ac)
814		-	require.True(t, syncTimer.stopped.Load(), "sync watchdog must be stopped")
	849	+	syncTimer.mock.AssertNumberOfCalls(t, "Stop", 1)
815	850		requireWorkerExit(t, syncDone)
816	851		})
817	852		}
818	853		}
819	854
820	855		func TestRenderCoordinatorRetainsPR71ResizeDispatch(t *testing.T) {
821		-	newResizeFixture := func(t testing.T) (Daemon, session, attachedClient, chan ports.Frame, *signalClock, chan renderInvalidation) {
	856	+	newResizeFixture := func(t testing.T) (Daemon, session, attachedClient, chan ports.Frame, *coordinatorMockClock, chan renderInvalidation) {
822	857		t.Helper()
823	858		p, releasePTY := newBlockingPTY(t)
824	859		t.Cleanup(releasePTY)
825	860		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
826		-	clk := &signalClock{timers: make(chan *signalTimer, 4)}
827		-	d.clock = clk
	861	+	clk := newCoordinatorMockClock(t, 4)
	862	+	d.clock = clk.clock
828	863		invs := make(chan renderInvalidation, 4)
829	864		sess.installRenderCoordinator(newRenderCoordinator(renderCoordinatorOptions{
830		-	clock: clk,
	865	+	clock: clk.clock,
831	866		wake: func(renderWake) {},
832	867		onInvalidate: func(inv renderInvalidation) { invs <- inv },
833	868		}))

@@ -838,7 +873,7 @@ func TestRenderCoordinatorRetainsPR71ResizeDispatch(t *testing.T) {
838	873		d, sess, ac, sends, clk, invs := newResizeFixture(t)
839	874
840	875		d.resize(sess, ac, domain.Size{Cols: 120, Rows: 24})
841		-	timer := awaitScheduledTimer(t, clk)
	876	+	timer := awaitCoordinatorScheduledTimer(t, clk)
842	877		require.GreaterOrEqual(t, timer.duration, minOutputRenderDeadline)
843	878		require.LessOrEqual(t, timer.duration, maxOutputRenderDeadline)
844	879		ac.sendMu.Lock()

@@ -865,9 +900,9 @@ func TestRenderCoordinatorRetainsPR71ResizeDispatch(t *testing.T) {
865	900		d, sess, ac, sends, clk, invs := newResizeFixture(t)
866	901
867	902		d.resize(sess, ac, domain.Size{Cols: 100, Rows: 24})
868		-	first := awaitScheduledTimer(t, clk)
	903	+	first := awaitCoordinatorScheduledTimer(t, clk)
869	904		d.resize(sess, ac, domain.Size{Cols: 120, Rows: 24})
870		-	latest := awaitScheduledTimer(t, clk)
	905	+	latest := awaitCoordinatorScheduledTimer(t, clk)
871	906		require.Equal(t, uint64(2), sess.renderCoordinator().resizeSnapshot().epoch,
872	907		"every resize request must advance the coordinator epoch")
873	908

@@ -887,7 +922,7 @@ func TestRenderCoordinatorRetainsPR71ResizeDispatch(t *testing.T) {
887	922		d, sess, ac, sends, clk, invs := newResizeFixture(t)
888	923
889	924		d.resize(sess, ac, domain.Size{Cols: 90, Rows: 30})
890		-	timer := awaitScheduledTimer(t, clk)
	925	+	timer := awaitCoordinatorScheduledTimer(t, clk)
891	926		ac.cancelResizePaint()
892	927
893	928		timer.ch <- time.Time{}

 	"testing"
 	"time"
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/usecase/keys"
 	"github.com/bnema/vev/internal/usecase/layout"
 )
 // --- coordinator harness ------------------------------------------------------
-// coordinatorHarness wires one coordinator to a fake clock and recording
+// coordinatorMockClock uses generated mocks while retaining deterministic timer
-// hooks. Every assertion is channel- or counter-based; nothing sleeps.
+// channels and recorded deadlines for coordinator scheduling assertions.
+type coordinatorMockClock struct {
+	clock  *portsmocks.MockClock
+	timers chan *coordinatorMockTimer
+	inert  bool
+}
+type coordinatorMockTimer struct {
+	mock     *portsmocks.MockTimer
+	ch       chan time.Time
+	duration time.Duration
+}
+func newCoordinatorMockClock(t *testing.T, capacity int) *coordinatorMockClock {
+	t.Helper()
+	clk := &coordinatorMockClock{
+		clock:  portsmocks.NewMockClock(t),
+		timers: make(chan *coordinatorMockTimer, capacity),
+	}
+	clk.clock.EXPECT().Now().Return(time.Time{}).Maybe()
+	clk.clock.EXPECT().NewTimer(mock.MatchedBy(func(d time.Duration) bool {
+		return d == urgentRenderDeadline ||
+			(d >= minOutputRenderDeadline && d <= maxOutputRenderDeadline) ||
+			d == maxSyncUpdateDuration
+	})).RunAndReturn(func(d time.Duration) ports.Timer {
+		timer := &coordinatorMockTimer{
+			mock:     portsmocks.NewMockTimer(t),
+			duration: d,
+		}
+		if !clk.inert {
+			timer.ch = make(chan time.Time, 1)
+		}
+		// A normal deadline reads C both in its worker and in the inert-clock
+		// guard; a watchdog reads it in its worker. The generated expectation
+		// makes every channel access observable without a hand-written Timer.
+		timer.mock.EXPECT().C().Maybe().Return((<-chan time.Time)(timer.ch))
+		timer.mock.EXPECT().Stop().Maybe().Return(true)
+		clk.timers <- timer
+		return timer.mock
+	}).Maybe()
+	return clk
+}
+func newInertCoordinatorMockClock(t *testing.T, capacity int) *coordinatorMockClock {
+	clk := newCoordinatorMockClock(t, capacity)
+	clk.inert = true
+	return clk
+}
+// coordinatorHarness wires one coordinator to generated clock/timer mocks and
+// recording hooks. Every assertion is channel- or counter-based; nothing sleeps.
 type coordinatorHarness struct {
-	clk        *signalClock
+	clk        *coordinatorMockClock
 	wakes      chan renderWake
 	previews   chan renderWake
 	ackReady   atomic.Bool
 func newCoordinatorHarness(t *testing.T) *coordinatorHarness {
 	t.Helper()
 	h := &coordinatorHarness{
-		clk:      &signalClock{timers: make(chan *signalTimer, 16)},
+		clk:      newCoordinatorMockClock(t, 16),
 		wakes:    make(chan renderWake, 16),
 		previews: make(chan renderWake, 16),
 	}
 	h.ackReady.Store(true)
 	h.rc = newRenderCoordinator(renderCoordinatorOptions{
-		clock:      h.clk,
+		clock:      h.clk.clock,
 		wake:       func(w renderWake) { h.wakes <- w },
 		ackReady:   func() bool { return h.ackReady.Load() },
 		syncActive: func() bool { return h.syncActive.Load() },
 // armedTimers drains every deadline armed so far. Arming happens
 // synchronously inside the coordinator call, so a non-blocking drain is
 // deterministic.
-func (h *coordinatorHarness) armedTimers(t *testing.T) []*signalTimer {
+func (h *coordinatorHarness) armedTimers(t *testing.T) []*coordinatorMockTimer {
 	t.Helper()
-	var timers []*signalTimer
+	var timers []*coordinatorMockTimer
 	for {
 		select {
 		case tm := <-h.clk.timers:
 	}
 }
-func awaitScheduledTimer(t *testing.T, clk *signalClock) *signalTimer {
+func awaitCoordinatorScheduledTimer(t *testing.T, clk *coordinatorMockClock) *coordinatorMockTimer {
 	t.Helper()
 	select {
 	case tm := <-clk.timers:
 			file: "render.go",
 			name: "retained resize dispatch",
 			run: func(t *testing.T, d *Daemon, sess *session, ac *attachedClient) {
-				clk := &signalClock{timers: make(chan *signalTimer, 2)}
+				clk := newCoordinatorMockClock(t, 2)
-				d.clock = clk
+				d.clock = clk.clock
 				d.resize(sess, ac, domain.Size{Cols: 100, Rows: 26})
-				awaitScheduledTimer(t, clk).ch <- time.Time{}
+				awaitCoordinatorScheduledTimer(t, clk).ch <- time.Time{}
 			},
 		},
 		{
 	}
 }
-// inertTimer deliberately has a nil C channel. It verifies coordinator
-// lifecycle paths do not strand workers behind fake clocks that never fire.
-type inertTimer struct{ stopped atomic.Bool }
-func (t *inertTimer) C() <-chan time.Time      { return nil }
-func (t *inertTimer) Reset(time.Duration) bool { return false }
-func (t *inertTimer) Stop() bool               { t.stopped.Store(true); return true }
-type inertClock struct{ timers chan *inertTimer }
-func (c *inertClock) Now() time.Time { return time.Time{} }
-func (c *inertClock) NewTimer(time.Duration) ports.Timer {
-	t := &inertTimer{}
-	c.timers <- t
-	return t
-}
 func requireWorkerExit(t *testing.T, done <-chan struct{}) {
 	t.Helper()
 	for range 4096 {
 	}
 	for _, tc := range lifecycle {
 		t.Run(tc.name, func(t *testing.T) {
-			clk := &inertClock{timers: make(chan *inertTimer, 2)}
+			clk := newInertCoordinatorMockClock(t, 2)
-			rc := newRenderCoordinator(renderCoordinatorOptions{clock: clk})
+			rc := newRenderCoordinator(renderCoordinatorOptions{clock: clk.clock})
 			ac := &attachedClient{}
 			rc.attach(ac)
 			rc.invalidate(renderInvalidation{class: invalidateOutput})
 			normalDone := rc.normalWorkerDone
 			rc.mu.Unlock()
 			tc.end(rc, ac)
-			require.True(t, normal.stopped.Load(), "normal timer must be stopped")
+			normal.mock.AssertNumberOfCalls(t, "Stop", 1)
 			requireWorkerExit(t, normalDone)
 			// Use a fresh coordinator because detach/teardown intentionally makes
 			// an attachment ineligible for a new synchronized batch.
-			rc = newRenderCoordinator(renderCoordinatorOptions{clock: clk})
+			rc = newRenderCoordinator(renderCoordinatorOptions{clock: clk.clock})
 			rc.attach(ac)
 			rc.noteSyncBegin(1)
 			syncTimer := <-clk.timers
 			syncDone := rc.syncWorkerDone
 			rc.mu.Unlock()
 			tc.end(rc, ac)
-			require.True(t, syncTimer.stopped.Load(), "sync watchdog must be stopped")
+			syncTimer.mock.AssertNumberOfCalls(t, "Stop", 1)
 			requireWorkerExit(t, syncDone)
 		})
 	}
 }
 func TestRenderCoordinatorRetainsPR71ResizeDispatch(t *testing.T) {
-	newResizeFixture := func(t *testing.T) (*Daemon, *session, *attachedClient, chan ports.Frame, *signalClock, chan renderInvalidation) {
+	newResizeFixture := func(t *testing.T) (*Daemon, *session, *attachedClient, chan ports.Frame, *coordinatorMockClock, chan renderInvalidation) {
 		t.Helper()
 		p, releasePTY := newBlockingPTY(t)
 		t.Cleanup(releasePTY)
 		d, sess, ac, sends := newManualSessionWithPTYs(t, p)
-		clk := &signalClock{timers: make(chan *signalTimer, 4)}
+		clk := newCoordinatorMockClock(t, 4)
-		d.clock = clk
+		d.clock = clk.clock
 		invs := make(chan renderInvalidation, 4)
 		sess.installRenderCoordinator(newRenderCoordinator(renderCoordinatorOptions{
-			clock:        clk,
+			clock:        clk.clock,
 			wake:         func(renderWake) {},
 			onInvalidate: func(inv renderInvalidation) { invs <- inv },
 		}))
 		d, sess, ac, sends, clk, invs := newResizeFixture(t)
 		d.resize(sess, ac, domain.Size{Cols: 120, Rows: 24})
-		timer := awaitScheduledTimer(t, clk)
+		timer := awaitCoordinatorScheduledTimer(t, clk)
 		require.GreaterOrEqual(t, timer.duration, minOutputRenderDeadline)
 		require.LessOrEqual(t, timer.duration, maxOutputRenderDeadline)
 		ac.sendMu.Lock()
 		d, sess, ac, sends, clk, invs := newResizeFixture(t)
 		d.resize(sess, ac, domain.Size{Cols: 100, Rows: 24})
-		first := awaitScheduledTimer(t, clk)
+		first := awaitCoordinatorScheduledTimer(t, clk)
 		d.resize(sess, ac, domain.Size{Cols: 120, Rows: 24})
-		latest := awaitScheduledTimer(t, clk)
+		latest := awaitCoordinatorScheduledTimer(t, clk)
 		require.Equal(t, uint64(2), sess.renderCoordinator().resizeSnapshot().epoch,
 			"every resize request must advance the coordinator epoch")
 		d, sess, ac, sends, clk, invs := newResizeFixture(t)
 		d.resize(sess, ac, domain.Size{Cols: 90, Rows: 30})
-		timer := awaitScheduledTimer(t, clk)
+		timer := awaitCoordinatorScheduledTimer(t, clk)
 		ac.cancelResizePaint()
 		timer.ch <- time.Time{}

M internal/usecase/daemon/snapshot_test.go +3 -3


@@ -221,9 +221,9 @@ func TestPTYReaderSameReadSynchronizedOutputUsesUrgentCoordinatorDeadline(t *tes
221	221		tb := newTestTabWithContext(p, sctx, cancel)
222	222		sess := &session{id: "sync-urgent", name: "sync-urgent", tabs: []*tab{tb}, ctx: sctx, cancel: cancel}
223	223		invs := make(chan renderInvalidation, 1)
224		-	clock := &signalClock{timers: make(chan *signalTimer, 2)}
	224	+	clock := newCoordinatorMockClock(t, 2)
225	225		sess.installRenderCoordinator(newRenderCoordinator(renderCoordinatorOptions{
226		-	clock: clock,
	226	+	clock: clock.clock,
227	227		onInvalidate: func(inv renderInvalidation) { invs <- inv },
228	228		}))
229	229		d.sessions[sess.id] = sess

@@ -232,7 +232,7 @@ func TestPTYReaderSameReadSynchronizedOutputUsesUrgentCoordinatorDeadline(t *tes
232	232
233	233		inv := awaitInvalidation(t, invs)
234	234		require.Equal(t, invalidateUrgent, inv.class, "a complete same-read synchronized batch must flush urgently")
235		-	timer := awaitScheduledTimer(t, clock)
	235	+	timer := awaitCoordinatorScheduledTimer(t, clock)
236	236		require.Equal(t, urgentRenderDeadline, timer.duration)
237	237		}
238	238


@@ -221,9 +221,9 @@ func TestPTYReaderSameReadSynchronizedOutputUsesUrgentCoordinatorDeadline(t *tes
221		tb := newTestTabWithContext(p, sctx, cancel)	221		tb := newTestTabWithContext(p, sctx, cancel)
222		sess := &session{id: "sync-urgent", name: "sync-urgent", tabs: []*tab{tb}, ctx: sctx, cancel: cancel}	222		sess := &session{id: "sync-urgent", name: "sync-urgent", tabs: []*tab{tb}, ctx: sctx, cancel: cancel}
223		invs := make(chan renderInvalidation, 1)	223		invs := make(chan renderInvalidation, 1)
224	-	clock := &signalClock{timers: make(chan *signalTimer, 2)}	224	+	clock := newCoordinatorMockClock(t, 2)
225		sess.installRenderCoordinator(newRenderCoordinator(renderCoordinatorOptions{	225		sess.installRenderCoordinator(newRenderCoordinator(renderCoordinatorOptions{
226	-	clock: clock,	226	+	clock: clock.clock,
227		onInvalidate: func(inv renderInvalidation) { invs <- inv },	227		onInvalidate: func(inv renderInvalidation) { invs <- inv },
228		}))	228		}))
229		d.sessions[sess.id] = sess	229		d.sessions[sess.id] = sess

@@ -232,7 +232,7 @@ func TestPTYReaderSameReadSynchronizedOutputUsesUrgentCoordinatorDeadline(t *tes
232			232
233		inv := awaitInvalidation(t, invs)	233		inv := awaitInvalidation(t, invs)
234		require.Equal(t, invalidateUrgent, inv.class, "a complete same-read synchronized batch must flush urgently")	234		require.Equal(t, invalidateUrgent, inv.class, "a complete same-read synchronized batch must flush urgently")
235	-	timer := awaitScheduledTimer(t, clock)	235	+	timer := awaitCoordinatorScheduledTimer(t, clock)
236		require.Equal(t, urgentRenderDeadline, timer.duration)	236		require.Equal(t, urgentRenderDeadline, timer.duration)
237		}	237		}
238			238