test(daemon): pin transient page savings against a no-scratch baseline and cover modal and failed publications

commit: df3f959b73009ad9d739ff6f806d17fd4770392f
author: brice · 14d ago · 2026-10-08 07:31 UTC
committer: brice · 14d ago · 2026-10-08 08:12 UTC
parent: d5dd60d
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email
refs: perf/render-copy-allocations

1 file · +38 -12

M internal/usecase/daemon/render_transient_frames_test.go +38 -12


@@ -5,6 +5,7 @@ import (
5	5
6	6		renderer "github.com/bnema/vev-vt"
7	7		"github.com/bnema/vev/internal/domain"
	8	+	"github.com/bnema/vev/internal/usecase/ui"
8	9		"github.com/stretchr/testify/require"
9	10		)
10	11

@@ -24,7 +25,7 @@ func framesShareStorage(a, b renderer.Frame) bool {
24	25		return shared
25	26		}
26	27
27		-	func transientToastFloatingState(withToast, withFloating bool, seed rune) capturedRenderState {
	28	+	func transientToastFloatingState(withToast, withFloating, withModal bool, seed rune) capturedRenderState {
28	29		var notices []domain.Notification
29	30		if withToast {
30	31		notices = []domain.Notification{{Code: domain.NoticeClipboard, Severity: domain.NoticeInfo, Message: "copied", Count: 1}}

@@ -42,26 +43,46 @@ func transientToastFloatingState(withToast, withFloating bool, seed rune) captur
42	43		generation: 1,
43	44		}
44	45		}
	46	+	if withModal {
	47	+	// A modal without toast or floating is the second writer of the
	48	+	// overlay transient page.
	49	+	state.overlays.promptActive = true
	50	+	state.overlays.prompt = capturedModal{
	51	+	active: true,
	52	+	title: "Prompt",
	53	+	presentation: ui.Presentation{
	54	+	Bounds: domain.Rect{X: 10, Y: 5, Width: 20, Height: 3},
	55	+	Inner: domain.Rect{X: 11, Y: 6, Width: 18, Height: 1},
	56	+	Borders: ui.BorderAll,
	57	+	},
	58	+	}
	59	+	}
45	60		return state
46	61		}
47	62
48	63		// TestComposeFrameTransientScratchNeverAliasesCaches replays the attachment
49		-	// commit/spare rotation across toast, floating, and plain frames. Each result
	64	+	// commit/spare rotation across toast, floating, modal, and plain frames, and
	65	+	// across failed publications that compose again without committing. Each result
50	66		// must match an independent composition without scratch, the retained cache
51	67		// must stay toast-free, and no handed-out frame may share a page with either
52	68		// cache slot (which would let a later paint corrupt committed state).
53	69		func TestComposeFrameTransientScratchNeverAliasesCaches(t *testing.T) {
54	70		type step struct {
55		-	toast, floating bool
	71	+	toast, floating, modal bool
	72	+	// failed skips commitComposition, as a failed prepare or send does, so
	73	+	// the next step composes again from the same spare.
	74	+	failed bool
56	75		}
57	76		steps := []step{
58		-	{false, false}, {true, false}, {true, false}, {true, true}, {false, true},
59		-	{true, true}, {true, false}, {false, false}, {true, false}, {false, true}, {true, true},
	77	+	{}, {toast: true}, {toast: true}, {toast: true, floating: true}, {floating: true},
	78	+	{modal: true}, {modal: true, failed: true}, {modal: true}, {toast: true, modal: true},
	79	+	{toast: true, floating: true, failed: true}, {toast: true, floating: true}, {toast: true},
	80	+	{}, {toast: true, failed: true}, {toast: true}, {floating: true}, {toast: true, floating: true},
60	81		}
61	82		var render attachmentRenderState
62	83		for i, st := range steps {
63	84		seed := rune('A' + i)
64		-	state := transientToastFloatingState(st.toast, st.floating, seed)
	85	+	state := transientToastFloatingState(st.toast, st.floating, st.modal, seed)
65	86		state.reset = i == 0
66	87		// A frame without scratch is the reference: it only ever clones.
67	88		want := composeFrame(state, render.cache)

@@ -75,17 +96,17 @@ func TestComposeFrameTransientScratchNeverAliasesCaches(t *testing.T) {
75	96		// must never touch the committed cache a failed publication falls back to.
76	97		require.False(t, framesShareStorage(got.frame, render.cache.frame), "step %d: composed frame aliases the committed cache", i)
77	98		require.False(t, framesShareStorage(got.cache.frame, render.cache.frame), "step %d: new cache base aliases the committed cache", i)
78		-	if st.toast \|\| st.floating {
	99	+	if st.toast \|\| st.floating \|\| st.modal {
79	100		// A decorated frame lives on a transient page: never the cache base
80	101		// (toast-free by contract) nor the committed or spare cache pages.
81	102		require.False(t, framesShareStorage(got.frame, got.cache.frame), "step %d: decorated frame aliases the cache base", i)
82	103		require.False(t, framesShareStorage(got.frame, render.spare.frame), "step %d: decorated frame aliases the spare cache", i)
83	104		}
84		-	if !st.toast {
85		-	require.NotContains(t, frameText(got.cache.frame), "copied")
86		-	}
87	105		require.NotContains(t, frameText(got.cache.frame), "copied", "step %d: cache must stay toast-free", i)
88	106
	107	+	if st.failed {
	108	+	continue
	109	+	}
89	110		beforeCommitted := frameRows(render.cache.frame)
90	111		render.commitComposition(got.cache)
91	112		if i > 0 {

@@ -122,9 +143,14 @@ func TestComposeFrameStableToastReusesScratchPages(t *testing.T) {
122	143		out := composeFrame(state, cache, scratch)
123	144		scratch, cache = cache, out.cache
124	145		})
	146	+	// The baseline composes the same frame without scratch, so it clones the
	147	+	// base page every time. Reuse must save at least one full Clone.
	148	+	baseline := testing.AllocsPerRun(50, func() {
	149	+	benchmarkComposeSink.frame = composeFrame(state, cache, composeCacheInput{}).frame
	150	+	})
125	151		cloned := testing.AllocsPerRun(50, func() { benchmarkComposeSink.frame = cache.frame.Clone() })
126		-	require.Less(t, reused, 30.0, "per-frame compose allocations")
127		-	t.Logf("compose allocs=%v, one Clone allocs=%v", reused, cloned)
	152	+	require.Positive(t, cloned)
	153	+	require.LessOrEqual(t, reused, baseline-cloned, "scratch reuse must save at least one Clone (baseline=%v clone=%v)", baseline, cloned)
128	154		out := composeFrame(state, cache, scratch)
129	155		require.False(t, framesShareStorage(out.frame, out.cache.frame))
130	156		require.Contains(t, frameText(out.frame), "copied")

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/usecase/ui"
 	"github.com/stretchr/testify/require"
 )
 	return shared
 }
-func transientToastFloatingState(withToast, withFloating bool, seed rune) capturedRenderState {
+func transientToastFloatingState(withToast, withFloating, withModal bool, seed rune) capturedRenderState {
 	var notices []domain.Notification
 	if withToast {
 		notices = []domain.Notification{{Code: domain.NoticeClipboard, Severity: domain.NoticeInfo, Message: "copied", Count: 1}}
 			generation: 1,
 		}
 	}
+	if withModal {
+		// A modal without toast or floating is the second writer of the
+		// overlay transient page.
+		state.overlays.promptActive = true
+		state.overlays.prompt = capturedModal{
+			active: true,
+			title:  "Prompt",
+			presentation: ui.Presentation{
+				Bounds:  domain.Rect{X: 10, Y: 5, Width: 20, Height: 3},
+				Inner:   domain.Rect{X: 11, Y: 6, Width: 18, Height: 1},
+				Borders: ui.BorderAll,
+			},
+		}
+	}
 	return state
 }
 // TestComposeFrameTransientScratchNeverAliasesCaches replays the attachment
-// commit/spare rotation across toast, floating, and plain frames. Each result
+// commit/spare rotation across toast, floating, modal, and plain frames, and
+// across failed publications that compose again without committing. Each result
 // must match an independent composition without scratch, the retained cache
 // must stay toast-free, and no handed-out frame may share a page with either
 // cache slot (which would let a later paint corrupt committed state).
 func TestComposeFrameTransientScratchNeverAliasesCaches(t *testing.T) {
 	type step struct {
-		toast, floating bool
+		toast, floating, modal bool
+		// failed skips commitComposition, as a failed prepare or send does, so
+		// the next step composes again from the same spare.
+		failed bool
 	}
 	steps := []step{
-		{false, false}, {true, false}, {true, false}, {true, true}, {false, true},
+		{}, {toast: true}, {toast: true}, {toast: true, floating: true}, {floating: true},
-		{true, true}, {true, false}, {false, false}, {true, false}, {false, true}, {true, true},
+		{modal: true}, {modal: true, failed: true}, {modal: true}, {toast: true, modal: true},
+		{toast: true, floating: true, failed: true}, {toast: true, floating: true}, {toast: true},
+		{}, {toast: true, failed: true}, {toast: true}, {floating: true}, {toast: true, floating: true},
 	}
 	var render attachmentRenderState
 	for i, st := range steps {
 		seed := rune('A' + i)
-		state := transientToastFloatingState(st.toast, st.floating, seed)
+		state := transientToastFloatingState(st.toast, st.floating, st.modal, seed)
 		state.reset = i == 0
 		// A frame without scratch is the reference: it only ever clones.
 		want := composeFrame(state, render.cache)
 		// must never touch the committed cache a failed publication falls back to.
 		require.False(t, framesShareStorage(got.frame, render.cache.frame), "step %d: composed frame aliases the committed cache", i)
 		require.False(t, framesShareStorage(got.cache.frame, render.cache.frame), "step %d: new cache base aliases the committed cache", i)
-		if st.toast || st.floating {
+		if st.toast || st.floating || st.modal {
 			// A decorated frame lives on a transient page: never the cache base
 			// (toast-free by contract) nor the committed or spare cache pages.
 			require.False(t, framesShareStorage(got.frame, got.cache.frame), "step %d: decorated frame aliases the cache base", i)
 			require.False(t, framesShareStorage(got.frame, render.spare.frame), "step %d: decorated frame aliases the spare cache", i)
 		}
-		if !st.toast {
-			require.NotContains(t, frameText(got.cache.frame), "copied")
-		}
 		require.NotContains(t, frameText(got.cache.frame), "copied", "step %d: cache must stay toast-free", i)
+		if st.failed {
+			continue
+		}
 		beforeCommitted := frameRows(render.cache.frame)
 		render.commitComposition(got.cache)
 		if i > 0 {
 		out := composeFrame(state, cache, scratch)
 		scratch, cache = cache, out.cache
 	})
+	// The baseline composes the same frame without scratch, so it clones the
+	// base page every time. Reuse must save at least one full Clone.
+	baseline := testing.AllocsPerRun(50, func() {
+		benchmarkComposeSink.frame = composeFrame(state, cache, composeCacheInput{}).frame
+	})
 	cloned := testing.AllocsPerRun(50, func() { benchmarkComposeSink.frame = cache.frame.Clone() })
-	require.Less(t, reused, 30.0, "per-frame compose allocations")
+	require.Positive(t, cloned)
-	t.Logf("compose allocs=%v, one Clone allocs=%v", reused, cloned)
+	require.LessOrEqual(t, reused, baseline-cloned, "scratch reuse must save at least one Clone (baseline=%v clone=%v)", baseline, cloned)
 	out := composeFrame(state, cache, scratch)
 	require.False(t, framesShareStorage(out.frame, out.cache.frame))
 	require.Contains(t, frameText(out.frame), "copied")