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: "exact theme accent beats a looser regular bright pair",
75 theme: func() Theme {
76 t := paletteTheme(map[int]renderer.RGB{
77 0: {R: 0xf4, G: 0xf7, B: 0xf5},
78 1: {R: 0xb6, G: 0x4d, B: 0x58},
79 2: {R: 0x3d, G: 0x66, B: 0x66},
80 3: {R: 0x8f, G: 0x62, B: 0x2b},
81 4: {R: 0x42, G: 0x6f, B: 0xa8},
82 5: {R: 0x74, G: 0x6f, B: 0x76},
83 6: {R: 0x5a, G: 0x85, B: 0x85},
84 7: {R: 0x1d, G: 0x22, B: 0x24},
85 8: {R: 0x75, G: 0x79, B: 0x82},
86 9: {R: 0xa9, G: 0x47, B: 0x51},
87 10: {R: 0x2a, G: 0x4a, B: 0x4a},
88 11: {R: 0x7d, G: 0x55, B: 0x25},
89 12: {R: 0x34, G: 0x5f, B: 0x95},
90 13: {R: 0x62, G: 0x5d, B: 0x64},
91 14: {R: 0x3d, G: 0x66, B: 0x66},
92 15: {R: 0x08, G: 0x09, B: 0x0a},
93 })
94 t.Foreground = renderer.RGB{R: 0x1d, G: 0x22, B: 0x24}
95 t.Background = renderer.RGB{R: 0xf4, G: 0xf7, B: 0xf5}
96 t.Light = true
97 return t
98 }(),
99 want: Accent{RGB: renderer.RGB{R: 0x3d, G: 0x66, B: 0x66}, Slot: 2, Known: true},
100 },
101 {
102 name: "regular bright pair beats equal size runner up",
103 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 4: blue, 13: blue}),
104 want: Accent{RGB: teal, Slot: 2, Known: true},
105 },
106 {
107 name: "neutral slots excluded from auto",
108 theme: paletteTheme(map[int]renderer.RGB{0: teal, 7: teal, 8: teal, 15: teal}),
109 want: Accent{},
110 },
111 {
112 name: "low chroma is rejected",
113 theme: paletteTheme(map[int]renderer.RGB{
114 1: {R: 60, G: 61, B: 60}, 9: {R: 60, G: 61, B: 60},
115 }),
116 want: Accent{},
117 },
118 {
119 name: "near background is rejected",
120 theme: paletteTheme(map[int]renderer.RGB{
121 1: {R: 9, G: 8, B: 12}, 9: {R: 9, G: 8, B: 12},
122 }),
123 want: Accent{},
124 },
125 {
126 name: "missing foreground yields indexed fallback only",
127 theme: func() Theme { t := paletteTheme(map[int]renderer.RGB{2: teal, 10: teal}); t.HasFG = false; return t }(),
128 want: Accent{RGB: teal, Slot: 2, Known: true, IndexedOnly: true},
129 },
130 {
131 name: "known colors remain semantic without truecolor output",
132 theme: func() Theme {
133 t := paletteTheme(map[int]renderer.RGB{2: teal, 10: teal})
134 return t
135 }(),
136 want: Accent{RGB: teal, Slot: 2, Known: true},
137 },
138 {
139 name: "missing background cannot infer",
140 theme: func() Theme { t := paletteTheme(map[int]renderer.RGB{2: teal, 10: teal}); t.HasBG = false; return t }(),
141 want: Accent{},
142 },
143 {
144 name: "palette disabled ignores accent policy",
145 theme: func() Theme {
146 t := paletteTheme(map[int]renderer.RGB{2: teal, 10: teal})
147 t.UsePalette = false
148 return t
149 }(),
150 want: Accent{},
151 },
152 }
153
154 for _, tt := range tests {
155 t.Run(tt.name, func(t *testing.T) {
156 require.Equal(t, tt.want, ResolveAccent(tt.theme, domain.ThemeAccent{Mode: domain.ThemeAccentAuto}))
157 })
158 }
159}
160
161func TestResolveAccentExplicitSlot(t *testing.T) {
162 teal := renderer.RGB{R: 0x7d, G: 0xb5, B: 0xb5}
163 blue := renderer.RGB{R: 0x6c, G: 0x9b, B: 0xd9}
164 tests := []struct {
165 name string
166 theme Theme
167 policy domain.ThemeAccent
168 want Accent
169 }{
170 {
171 name: "known explicit neutral slot bypasses auto exclusions",
172 theme: paletteTheme(map[int]renderer.RGB{0: teal, 2: blue, 10: blue}),
173 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 0},
174 want: Accent{RGB: teal, Slot: 0, Known: true},
175 },
176 {
177 name: "known explicit slot bypasses eligibility",
178 theme: paletteTheme(map[int]renderer.RGB{3: {R: 9, G: 8, B: 12}, 2: teal, 10: teal}),
179 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 3},
180 want: Accent{RGB: renderer.RGB{R: 9, G: 8, B: 12}, Slot: 3, Known: true},
181 },
182 {
183 name: "unknown explicit slot keeps its exact indexed decoration",
184 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 4: blue}),
185 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 5},
186 want: Accent{Slot: 5, IndexedOnly: true},
187 },
188 {
189 name: "unknown final palette slot keeps its indexed decoration",
190 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 4: blue}),
191 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 15},
192 want: Accent{Slot: 15, IndexedOnly: true},
193 },
194 {
195 name: "first slot outside palette is rejected",
196 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 4: blue}),
197 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 16},
198 want: Accent{},
199 },
200 {
201 name: "maximum uint8 slot outside palette is rejected",
202 theme: paletteTheme(map[int]renderer.RGB{2: teal, 10: teal, 4: blue}),
203 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 255},
204 want: Accent{},
205 },
206 {
207 name: "explicit known slot remains semantic without truecolor output",
208 theme: paletteTheme(map[int]renderer.RGB{3: teal}),
209 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 3},
210 want: Accent{RGB: teal, Slot: 3, Known: true},
211 },
212 {
213 name: "palette off ignores explicit slot",
214 theme: func() Theme { t := paletteTheme(map[int]renderer.RGB{3: teal}); t.UsePalette = false; return t }(),
215 policy: domain.ThemeAccent{Mode: domain.ThemeAccentSlot, Slot: 3},
216 want: Accent{},
217 },
218 }
219 for _, tt := range tests {
220 t.Run(tt.name, func(t *testing.T) {
221 require.Equal(t, tt.want, ResolveAccent(tt.theme, tt.policy))
222 })
223 }
224}
225
226func TestResolveAccentDeterministicAcrossShuffledPaletteConstruction(t *testing.T) {
227 entries := []struct {
228 slot int
229 color renderer.RGB
230 }{
231 {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}},
232 {4, renderer.RGB{R: 0x6c, G: 0x9b, B: 0xd9}}, {12, renderer.RGB{R: 0x6c, G: 0x9b, B: 0xd9}},
233 }
234 want := Accent{RGB: renderer.RGB{R: 0x7d, G: 0xb5, B: 0xb5}, Slot: 2, Known: true}
235 rng := rand.New(rand.NewSource(1)) //nolint:gosec // deterministic test shuffle.
236 for i := 0; i < 50; i++ {
237 rng.Shuffle(len(entries), func(a, b int) { entries[a], entries[b] = entries[b], entries[a] })
238 palette := make(map[int]renderer.RGB, len(entries))
239 for _, entry := range entries {
240 palette[entry.slot] = entry.color
241 }
242 require.Equalf(t, want, ResolveAccent(paletteTheme(palette), domain.ThemeAccent{}), "shuffle %d", i)
243 }
244}
245
246func TestResolveAccentMedoidAndTieBreak(t *testing.T) {
247 group := accentGroup{members: 1<<0 | 1<<1 | 1<<2}
248 colors := [accentCandidateCount]oklab{
249 {L: 0.10, A: 0.10}, {L: 0.11, A: 0.10}, {L: 0.12, A: 0.10},
250 }
251 finalizeAccentGroup(&group, colors)
252 require.Equal(t, uint8(1), group.rep, "central member is the medoid")
253
254 color := renderer.RGB{R: 0x7d, G: 0xb5, B: 0xb5}
255 got := ResolveAccent(paletteTheme(map[int]renderer.RGB{3: color, 11: color}), domain.ThemeAccent{})
256 require.Equal(t, Accent{RGB: color, Slot: 3, Known: true}, got)
257}
258
259func TestResolveAccentAllocs(t *testing.T) {
260 theme := paletteTheme(map[int]renderer.RGB{
261 2: {R: 0x7d, G: 0xb5, B: 0xb5}, 10: {R: 0x7d, G: 0xb5, B: 0xb5}, 14: {R: 0x7d, G: 0xb5, B: 0xb5},
262 4: {R: 0x6c, G: 0x9b, B: 0xd9}, 12: {R: 0x6c, G: 0x9b, B: 0xd9},
263 })
264 require.Zero(t, testing.AllocsPerRun(1000, func() {
265 _ = ResolveAccent(theme, domain.ThemeAccent{})
266 }))
267}
268
269func paletteTheme(colors map[int]renderer.RGB) Theme {
270 theme := Theme{
271 Foreground: renderer.RGB{R: 0xe0, G: 0xe0, B: 0xe0},
272 Background: renderer.RGB{R: 0x08, G: 0x09, B: 0x0a},
273 HasFG: true,
274 HasBG: true,
275 Known: true,
276 UsePalette: true,
277 }
278 for slot, color := range colors {
279 theme.Palette[slot] = color
280 theme.PaletteKnown |= 1 << slot
281 }
282 return theme
283}