1package theme
2
3import (
4 "math/rand"
5 "testing"
6
7 renderer "github.com/bnema/vev-vt"
8 "github.com/bnema/vev/internal/domain"
9 "github.com/stretchr/testify/require"
10)
11
12func TestAccentCandidateSlotsAreFixedAndAscending(t *testing.T) {
13 want := [...]uint8{1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 14}
14 for i, slot := range want {
15 require.Equalf(t, slot, accentCandidateSlot(i), "candidate index %d", i)
16 }
17}
18
19func TestResolveAccentThresholds(t *testing.T) {
20 tests := []struct {
21 name string
22 color oklab
23 background oklab
24 want bool
25 }{
26 {name: "chroma below", color: oklab{L: accentMinBackgroundDistance, A: accentMinChroma - 0.000001}},
27 {name: "chroma at", color: oklab{L: accentMinBackgroundDistance, A: accentMinChroma}, want: true},
28 {name: "chroma above", color: oklab{L: accentMinBackgroundDistance, A: accentMinChroma + 0.000001}, want: true},
29 {name: "background distance below", color: oklab{L: accentMinBackgroundDistance - 0.000001, A: accentMinChroma}, background: oklab{A: accentMinChroma}},
30 {name: "background distance at", color: oklab{L: accentMinBackgroundDistance, A: accentMinChroma}, background: oklab{A: accentMinChroma}, want: true},
31 {name: "background distance above", color: oklab{L: accentMinBackgroundDistance + 0.000001, A: accentMinChroma}, background: oklab{A: accentMinChroma}, want: true},
32 }
33 for _, tt := range tests {
34 t.Run(tt.name, func(t *testing.T) {
35 require.Equal(t, tt.want, accentEligible(tt.color, tt.background))
36 })
37 }
38
39 a := oklab{}
40 require.True(t, accentConnected(a, oklab{L: accentClusterDistance - 0.000001}))
41 require.True(t, accentConnected(a, oklab{L: accentClusterDistance}))
42 require.False(t, accentConnected(a, oklab{L: accentClusterDistance + 0.000001}))
43}
44
45func TestResolveAccentAuto(t *testing.T) {
46 teal := renderer.RGB{R: 0x7d, G: 0xb5, B: 0xb5}
47 blue := renderer.RGB{R: 0x6c, G: 0x9b, B: 0xd9}
48 tests := []struct {
49 name string
50 theme Theme
51 want Accent
52 }{
53 {
54 name: "repeated teal beats repeated blue",
55 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 14: teal, 4: blue, 12: blue}),
56 want: Accent{RGB: teal, Slot: 2, Known: true},
57 },
58 {
59 name: "singleton falls back to slot four",
60 theme: paletteTheme(map[int]renderer.RGB{2: teal, 4: blue}),
61 want: Accent{RGB: blue, Slot: 4, Known: true},
62 },
63 {
64 name: "singleton falls back to slot twelve",
65 theme: paletteTheme(map[int]renderer.RGB{2: teal, 12: blue}),
66 want: Accent{RGB: blue, Slot: 12, Known: true},
67 },
68 {
69 name: "tied repeated groups fall back to blue",
70 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 4: blue, 12: blue}),
71 want: Accent{RGB: blue, Slot: 4, Known: true},
72 },
73 {
74 name: "regular bright pair beats equal size runner up",
75 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 4: blue, 13: blue}),
76 want: Accent{RGB: teal, Slot: 2, Known: true},
77 },
78 {
79 name: "neutral slots excluded from auto",
80 theme: paletteTheme(map[int]renderer.RGB{0: teal, 7: teal, 8: teal, 15: teal}),
81 want: Accent{},
82 },
83 {
84 name: "low chroma is rejected",
85 theme: paletteTheme(map[int]renderer.RGB{
86 1: {R: 60, G: 61, B: 60}, 9: {R: 60, G: 61, B: 60},
87 }),
88 want: Accent{},
89 },
90 {
91 name: "near background is rejected",
92 theme: paletteTheme(map[int]renderer.RGB{
93 1: {R: 9, G: 8, B: 12}, 9: {R: 9, G: 8, B: 12},
94 }),
95 want: Accent{},
96 },
97 {
98 name: "missing foreground yields indexed fallback only",
99 theme: func() Theme { t := paletteTheme(map[int]renderer.RGB{2: teal, 10: teal}); t.HasFG = false; return t }(),
100 want: Accent{RGB: teal, Slot: 2, Known: true, IndexedOnly: true},
101 },
102 {
103 name: "non truecolor yields indexed fallback only",
104 theme: func() Theme {
105 t := paletteTheme(map[int]renderer.RGB{2: teal, 10: teal})
106 t.TrueColor = false
107 return t
108 }(),
109 want: Accent{RGB: teal, Slot: 2, Known: true, IndexedOnly: true},
110 },
111 {
112 name: "missing background cannot infer",
113 theme: func() Theme { t := paletteTheme(map[int]renderer.RGB{2: teal, 10: teal}); t.HasBG = false; return t }(),
114 want: Accent{},
115 },
116 {
117 name: "palette disabled ignores accent policy",
118 theme: func() Theme {
119 t := paletteTheme(map[int]renderer.RGB{2: teal, 10: teal})
120 t.UsePalette = false
121 return t
122 }(),
123 want: Accent{},
124 },
125 }
126
127 for _, tt := range tests {
128 t.Run(tt.name, func(t *testing.T) {
129 require.Equal(t, tt.want, ResolveAccent(tt.theme, domain.ThemeAccent{Mode: domain.ThemeAccentAuto}))
130 })
131 }
132}
133
134func TestResolveAccentExplicitSlot(t *testing.T) {
135 teal := renderer.RGB{R: 0x7d, G: 0xb5, B: 0xb5}
136 blue := renderer.RGB{R: 0x6c, G: 0x9b, B: 0xd9}
137 tests := []struct {
138 name string
139 theme Theme
140 policy domain.ThemeAccent
141 want Accent
142 }{
143 {
144 name: "known explicit neutral slot bypasses auto exclusions",
145 theme: paletteTheme(map[int]renderer.RGB{0: teal, 2: blue, 10: blue}),
146 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 0},
147 want: Accent{RGB: teal, Slot: 0, Known: true},
148 },
149 {
150 name: "known explicit slot bypasses eligibility",
151 theme: paletteTheme(map[int]renderer.RGB{3: {R: 9, G: 8, B: 12}, 2: teal, 10: teal}),
152 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 3},
153 want: Accent{RGB: renderer.RGB{R: 9, G: 8, B: 12}, Slot: 3, Known: true},
154 },
155 {
156 name: "unknown explicit slot keeps its exact indexed decoration",
157 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 4: blue}),
158 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 5},
159 want: Accent{Slot: 5, IndexedOnly: true},
160 },
161 {
162 name: "unknown final palette slot keeps its indexed decoration",
163 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 4: blue}),
164 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 15},
165 want: Accent{Slot: 15, IndexedOnly: true},
166 },
167 {
168 name: "first slot outside palette is rejected",
169 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 4: blue}),
170 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 16},
171 want: Accent{},
172 },
173 {
174 name: "maximum uint8 slot outside palette is rejected",
175 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 4: blue}),
176 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 255},
177 want: Accent{},
178 },
179 {
180 name: "explicit known slot is indexed only without truecolor prerequisites",
181 theme: func() Theme { t := paletteTheme(map[int]renderer.RGB{3: teal}); t.TrueColor = false; return t }(),
182 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 3},
183 want: Accent{RGB: teal, Slot: 3, Known: true, IndexedOnly: true},
184 },
185 {
186 name: "palette off ignores explicit slot",
187 theme: func() Theme { t := paletteTheme(map[int]renderer.RGB{3: teal}); t.UsePalette = false; return t }(),
188 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 3},
189 want: Accent{},
190 },
191 }
192 for _, tt := range tests {
193 t.Run(tt.name, func(t *testing.T) {
194 require.Equal(t, tt.want, ResolveAccent(tt.theme, tt.policy))
195 })
196 }
197}
198
199func TestResolveAccentDeterministicAcrossShuffledPaletteConstruction(t *testing.T) {
200 entries := []struct {
201 slot int
202 color renderer.RGB
203 }{
204 {2, renderer.RGB{R: 0x7d, G: 0xb5, B: 0xb5}}, {10, renderer.RGB{R: 0x7d, G: 0xb5, B: 0xb5}}, {14, renderer.RGB{R: 0x7d, G: 0xb5, B: 0xb5}},
205 {4, renderer.RGB{R: 0x6c, G: 0x9b, B: 0xd9}}, {12, renderer.RGB{R: 0x6c, G: 0x9b, B: 0xd9}},
206 }
207 want := Accent{RGB: renderer.RGB{R: 0x7d, G: 0xb5, B: 0xb5}, Slot: 2, Known: true}
208 rng := rand.New(rand.NewSource(1)) //nolint:gosec // deterministic test shuffle.
209 for i := 0; i < 50; i++ {
210 rng.Shuffle(len(entries), func(a, b int) { entries[a], entries[b] = entries[b], entries[a] })
211 palette := make(map[int]renderer.RGB, len(entries))
212 for _, entry := range entries {
213 palette[entry.slot] = entry.color
214 }
215 require.Equalf(t, want, ResolveAccent(paletteTheme(palette), domain.ThemeAccent{}), "shuffle %d", i)
216 }
217}
218
219func TestResolveAccentMedoidAndTieBreak(t *testing.T) {
220 group := accentGroup{members: 1<<0 | 1<<1 | 1<<2}
221 colors := [accentCandidateCount]oklab{
222 {L: 0.10, A: 0.10}, {L: 0.11, A: 0.10}, {L: 0.12, A: 0.10},
223 }
224 finalizeAccentGroup(&group, colors)
225 require.Equal(t, uint8(1), group.rep, "central member is the medoid")
226
227 color := renderer.RGB{R: 0x7d, G: 0xb5, B: 0xb5}
228 got := ResolveAccent(paletteTheme(map[int]renderer.RGB{3: color, 11: color}), domain.ThemeAccent{})
229 require.Equal(t, Accent{RGB: color, Slot: 3, Known: true}, got)
230}
231
232func TestResolveAccentAllocs(t *testing.T) {
233 theme := paletteTheme(map[int]renderer.RGB{
234 2: {R: 0x7d, G: 0xb5, B: 0xb5}, 10: {R: 0x7d, G: 0xb5, B: 0xb5}, 14: {R: 0x7d, G: 0xb5, B: 0xb5},
235 4: {R: 0x6c, G: 0x9b, B: 0xd9}, 12: {R: 0x6c, G: 0x9b, B: 0xd9},
236 })
237 require.Zero(t, testing.AllocsPerRun(1000, func() {
238 _ = ResolveAccent(theme, domain.ThemeAccent{})
239 }))
240}
241
242func paletteTheme(colors map[int]renderer.RGB) Theme {
243 theme := Theme{
244 Foreground: renderer.RGB{R: 0xe0, G: 0xe0, B: 0xe0},
245 Background: renderer.RGB{R: 0x08, G: 0x09, B: 0x0a},
246 HasFG: true,
247 HasBG: true,
248 TrueColor: true,
249 Known: true,
250 UsePalette: true,
251 }
252 for slot, color := range colors {
253 theme.Palette[slot] = color
254 theme.PaletteKnown |= 1 << slot
255 }
256 return theme
257}