Debian Codegraph @

hugolib/sitesmatrix/vectorstores_test.go

raw
1 // Copyright 2025 The Hugo Authors. All rights reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13
14 package sitesmatrix_test
15
16 import (
17 "testing"
18
19 qt "github.com/frankban/quicktest"
20 "github.com/gohugoio/hugo/common/hashing"
21 "github.com/gohugoio/hugo/common/hmaps"
22 "github.com/gohugoio/hugo/hugolib/sitesmatrix"
23 )
24
25 func newTestDims() *sitesmatrix.ConfiguredDimensions {
26 return sitesmatrix.NewTestingDimensions([]string{"en", "no"}, []string{"v1", "v2", "v3"}, []string{"admin", "editor", "viewer", "guest"})
27 }
28
29 func TestIntSets(t *testing.T) {
30 c := qt.New(t)
31 testDims := newTestDims()
32
33 sets := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
34 hmaps.NewOrderedIntSet(1, 2),
35 hmaps.NewOrderedIntSet(1, 2, 3),
36 hmaps.NewOrderedIntSet(1, 2, 3),
37 ).Build()
38
39 sets2 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
40 hmaps.NewOrderedIntSet(1, 2),
41 hmaps.NewOrderedIntSet(1, 2, 3),
42 hmaps.NewOrderedIntSet(1, 2, 4),
43 ).Build()
44
45 sets3 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
46 hmaps.NewOrderedIntSet(2, 1),
47 hmaps.NewOrderedIntSet(1, 2, 3),
48 hmaps.NewOrderedIntSet(2, 1, 4),
49 ).Build()
50
51 sets4 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
52 hmaps.NewOrderedIntSet(3, 4, 5),
53 hmaps.NewOrderedIntSet(3, 4, 5),
54 hmaps.NewOrderedIntSet(3, 4, 5),
55 ).Build()
56
57 c.Assert(hashing.HashStringHex(sets), qt.Equals, "790f6004619934ff")
58 c.Assert(hashing.HashStringHex(sets2), qt.Equals, "99abddc51cd22f24")
59 c.Assert(hashing.HashStringHex(sets3), qt.Equals, "99abddc51cd22f24")
60
61 c.Assert(sets.HasVector(sitesmatrix.Vector{1, 2, 3}), qt.Equals, true)
62 c.Assert(sets.HasVector(sitesmatrix.Vector{3, 2, 3}), qt.Equals, false)
63 c.Assert(sets.HasAnyVector(sets2), qt.Equals, true)
64 c.Assert(sets.HasAnyVector(sets3), qt.Equals, true)
65 c.Assert(sets.HasAnyVector(sets4), qt.Equals, false)
66
67 c.Assert(sets.VectorSample(), qt.Equals, sitesmatrix.Vector{1, 1, 1})
68 c.Assert(sets.EqualsVector(sets), qt.Equals, true)
69 c.Assert(sets.EqualsVector(
70 sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
71 hmaps.NewOrderedIntSet(1, 2),
72 hmaps.NewOrderedIntSet(1, 2, 3),
73 hmaps.NewOrderedIntSet(1, 2, 3),
74 ).Build(),
75 ), qt.Equals, true)
76 c.Assert(sets.EqualsVector(
77 sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
78 hmaps.NewOrderedIntSet(1, 2, 3),
79 hmaps.NewOrderedIntSet(1, 2, 3, 4),
80 hmaps.NewOrderedIntSet(1, 2, 3, 4),
81 ).Build(),
82 ), qt.Equals, false)
83
84 c.Assert(sets.EqualsVector(
85 sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
86 hmaps.NewOrderedIntSet(1, 2),
87 hmaps.NewOrderedIntSet(1, 2, 3),
88 hmaps.NewOrderedIntSet(2, 3, 4),
89 ).Build(),
90 ), qt.Equals, false)
91
92 allCount := 0
93 seen := make(map[sitesmatrix.Vector]bool)
94 ok := sets.ForEachVector(func(v sitesmatrix.Vector) bool {
95 c.Assert(seen[v], qt.IsFalse)
96 seen[v] = true
97 allCount++
98 return true
99 })
100
101 c.Assert(ok, qt.IsTrue)
102
103 // 2 languages * 3 versions * 3 roles = 18 combinations.
104 c.Assert(allCount, qt.Equals, 18)
105 }
106
107 func TestIntSetsComplement(t *testing.T) {
108 c := qt.New(t)
109
110 type values struct {
111 v0 []int
112 v1 []int
113 v2 []int
114 }
115
116 type test struct {
117 name string
118 left values
119 input []values
120 expected []sitesmatrix.Vector
121 }
122
123 runOne := func(c *qt.C, test test) {
124 c.Helper()
125
126 testDims := newTestDims()
127
128 self := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
129 hmaps.NewOrderedIntSet(test.left.v0...),
130 hmaps.NewOrderedIntSet(test.left.v1...),
131 hmaps.NewOrderedIntSet(test.left.v2...),
132 ).Build()
133
134 var input []sitesmatrix.VectorProvider
135 for _, v := range test.input {
136 input = append(input, sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
137 hmaps.NewOrderedIntSet(v.v0...),
138 hmaps.NewOrderedIntSet(v.v1...),
139 hmaps.NewOrderedIntSet(v.v2...),
140 ).Build())
141 }
142
143 result := self.Complement(input...)
144
145 vectors := result.Vectors()
146 c.Assert(vectors, qt.DeepEquals, test.expected)
147
148 c.Assert(hashing.HashStringHex(result), qt.Not(qt.Equals), hashing.HashStringHex(self))
149 }
150
151 for _, test := range []test{
152 {
153 name: "Test 3",
154 left: values{
155 v0: []int{1, 3, 5},
156 v1: []int{1},
157 v2: []int{1},
158 },
159 input: []values{
160 {v0: []int{2}, v1: []int{1}, v2: []int{1}},
161 {v0: []int{2, 3}, v1: []int{1}, v2: []int{1}},
162 },
163 expected: []sitesmatrix.Vector{
164 {1, 1, 1},
165 {5, 1, 1},
166 },
167 },
168 {
169 name: "Test 1",
170 left: values{
171 v0: []int{1},
172 v1: []int{1},
173 v2: []int{1},
174 },
175 input: []values{
176 {v0: []int{2}, v1: []int{1}, v2: []int{1}},
177 },
178 expected: []sitesmatrix.Vector{
179 {1, 1, 1},
180 },
181 },
182 {
183 name: "Same values",
184 left: values{
185 v0: []int{1},
186 v1: []int{1},
187 v2: []int{1},
188 },
189 input: []values{
190 {v0: []int{1}, v1: []int{1}, v2: []int{1}},
191 },
192 expected: nil,
193 },
194 {
195 name: "Test 2",
196 left: values{
197 v0: []int{1, 3, 5},
198 v1: []int{1},
199 v2: []int{1},
200 },
201 input: []values{
202 {v0: []int{2}, v1: []int{1}, v2: []int{1}},
203 },
204 expected: []sitesmatrix.Vector{
205 {1, 1, 1},
206 {3, 1, 1},
207 {5, 1, 1},
208 },
209 },
210 {
211 name: "Many",
212 left: values{
213 v0: []int{1, 3, 5, 6, 7},
214 v1: []int{1, 3, 5, 6, 7},
215 v2: []int{1, 3, 5, 6, 7},
216 },
217 input: []values{
218 {
219 v0: []int{1, 3, 5, 6, 7},
220 v1: []int{1, 3, 5, 6},
221 v2: []int{1, 3, 5, 6, 7},
222 },
223 },
224 expected: []sitesmatrix.Vector{
225 {1, 7, 1},
226 {1, 7, 3},
227 {1, 7, 5},
228 {1, 7, 6},
229 {1, 7, 7},
230 {3, 7, 1},
231 {3, 7, 3},
232 {3, 7, 5},
233 {3, 7, 6},
234 {3, 7, 7},
235 {5, 7, 1},
236 {5, 7, 3},
237 {5, 7, 5},
238 {5, 7, 6},
239 {5, 7, 7},
240 {6, 7, 1},
241 {6, 7, 3},
242 {6, 7, 5},
243 {6, 7, 6},
244 {6, 7, 7},
245 {7, 7, 1},
246 {7, 7, 3},
247 {7, 7, 5},
248 {7, 7, 6},
249 {7, 7, 7},
250 },
251 },
252 } {
253 c.Run(test.name, func(c *qt.C) {
254 runOne(c, test)
255 })
256 }
257 }
258
259 func TestIntSetsComplementOfComplement(t *testing.T) {
260 c := qt.New(t)
261
262 testDims := newTestDims()
263
264 sets1 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
265 hmaps.NewOrderedIntSet(1),
266 hmaps.NewOrderedIntSet(1),
267 hmaps.NewOrderedIntSet(1),
268 ).Build()
269
270 sets2 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
271 hmaps.NewOrderedIntSet(1, 2),
272 hmaps.NewOrderedIntSet(1),
273 hmaps.NewOrderedIntSet(1, 3),
274 ).Build()
275
276 c1 := sets2.Complement(sets1)
277
278 vectors := c1.Vectors()
279 // c.Assert(len(vectors), qt.Equals, 3)
280 c.Assert(vectors, qt.DeepEquals, []sitesmatrix.Vector{
281 {1, 1, 3},
282 {2, 1, 1},
283 {2, 1, 3},
284 })
285
286 c.Assert(hashing.HashStringHex(c1), qt.Not(qt.Equals), hashing.HashStringHex(sets1))
287 c.Assert(hashing.HashStringHex(c1), qt.Not(qt.Equals), hashing.HashStringHex(sets2))
288
289 c2 := sets1.Complement(c1)
290 c.Assert(c2.Vectors(), qt.DeepEquals, []sitesmatrix.Vector{
291 {1, 1, 1},
292 })
293 }
294
295 func BenchmarkIntSetsComplement(b *testing.B) {
296 testDims := newTestDims()
297
298 sets1 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
299 hmaps.NewOrderedIntSet(1, 2, 3),
300 hmaps.NewOrderedIntSet(1, 2, 3),
301 hmaps.NewOrderedIntSet(1, 2, 3),
302 ).Build()
303
304 sets1Copy := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
305 hmaps.NewOrderedIntSet(1, 2, 3),
306 hmaps.NewOrderedIntSet(1, 2, 3),
307 hmaps.NewOrderedIntSet(1, 2, 3),
308 ).Build()
309
310 sets2 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
311 hmaps.NewOrderedIntSet(1, 2, 3, 4),
312 hmaps.NewOrderedIntSet(1, 2, 3, 4),
313 hmaps.NewOrderedIntSet(1, 2, 3, 4, 6),
314 ).Build()
315
316 setsLanguage1 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
317 hmaps.NewOrderedIntSet(1),
318 hmaps.NewOrderedIntSet(1),
319 hmaps.NewOrderedIntSet(1),
320 ).Build()
321
322 b.ResetTimer()
323 b.Run("sub set", func(b *testing.B) {
324 for b.Loop() {
325 _ = sets2.Complement(sets1)
326 }
327 })
328
329 b.Run("super set", func(b *testing.B) {
330 for b.Loop() {
331 _ = sets1.Complement(sets2)
332 }
333 })
334
335 b.Run("self", func(b *testing.B) {
336 for b.Loop() {
337 _ = sets1.Complement(sets1)
338 }
339 })
340
341 b.Run("self multiple", func(b *testing.B) {
342 for b.Loop() {
343 _ = sets1.Complement(sets1, sets1, sets1, sets1, sets1, sets1, sets1)
344 }
345 })
346
347 b.Run("same", func(b *testing.B) {
348 for b.Loop() {
349 _ = sets1.Complement(sets1Copy)
350 }
351 })
352
353 b.Run("one overlapping language", func(b *testing.B) {
354 for b.Loop() {
355 _ = setsLanguage1.Complement(sets1)
356 }
357 })
358 }
359
360 func BenchmarkSets(b *testing.B) {
361 testDims := newTestDims()
362
363 sets1 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
364 hmaps.NewOrderedIntSet(1, 2),
365 hmaps.NewOrderedIntSet(1, 2, 3),
366 hmaps.NewOrderedIntSet(1, 2, 3),
367 ).Build()
368
369 sets1Copy := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
370 hmaps.NewOrderedIntSet(1, 2),
371 hmaps.NewOrderedIntSet(1, 2, 3),
372 hmaps.NewOrderedIntSet(1, 2, 3),
373 ).Build()
374
375 sets2 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
376 hmaps.NewOrderedIntSet(1, 2, 3),
377 hmaps.NewOrderedIntSet(1, 2, 3, 4),
378 hmaps.NewOrderedIntSet(1, 2, 3, 4),
379 ).Build()
380
381 v1 := sitesmatrix.Vector{1, 2, 3}
382 v2 := sitesmatrix.Vector{3, 2, 3}
383
384 b.ResetTimer()
385 b.Run("Build", func(b *testing.B) {
386 for b.Loop() {
387 _ = sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
388 hmaps.NewOrderedIntSet(1, 2),
389 hmaps.NewOrderedIntSet(1, 2, 3),
390 hmaps.NewOrderedIntSet(1, 2, 3),
391 ).Build()
392 }
393 })
394 b.Run("HasVector", func(b *testing.B) {
395 for b.Loop() {
396 _ = sets1.HasVector(v1)
397 _ = sets1.HasVector(v2)
398 }
399 })
400
401 b.Run("HasAnyVector(Sets)", func(b *testing.B) {
402 for b.Loop() {
403 _ = sets1.HasAnyVector(sets2)
404 }
405 })
406 b.Run("HasAnyVector(Vector)", func(b *testing.B) {
407 for b.Loop() {
408 _ = sets1.HasAnyVector(v1)
409 }
410 })
411
412 b.Run("HasAnyVector(&Vector)", func(b *testing.B) {
413 for b.Loop() {
414 _ = sets1.HasAnyVector(&v1)
415 }
416 })
417
418 b.Run("FirstVector", func(b *testing.B) {
419 for b.Loop() {
420 _ = sets1.VectorSample()
421 }
422 })
423
424 b.Run("LenVectors", func(b *testing.B) {
425 for b.Loop() {
426 _ = sets1.LenVectors()
427 }
428 })
429
430 b.Run("ForEachVector", func(b *testing.B) {
431 for b.Loop() {
432 allCount := 0
433 ok := sets1.ForEachVector(func(v sitesmatrix.Vector) bool {
434 allCount++
435 _ = v
436 return true
437 })
438
439 if !ok {
440 b.Fatal("Expected ForEachVector to return true")
441 }
442
443 if allCount != 18 {
444 b.Fatalf("Expected 18 combinations, got %d", allCount)
445 }
446 }
447 })
448
449 b.Run("EqualsVector pointer equal", func(b *testing.B) {
450 for b.Loop() {
451 if !sets1.EqualsVector(sets1) {
452 b.Fatal("Expected sets1 to equal itself")
453 }
454 }
455 })
456
457 b.Run("EqualsVector equal copy", func(b *testing.B) {
458 for b.Loop() {
459 if !sets1.EqualsVector(sets1Copy) {
460 b.Fatal("Expected sets1 to equal its copy")
461 }
462 }
463 })
464
465 b.Run("EqualsVector different sets", func(b *testing.B) {
466 for b.Loop() {
467 if sets1.EqualsVector(sets2) {
468 b.Fatal("Expected sets1 to not equal sets2")
469 }
470 }
471 })
472
473 b.Run("Distance", func(b *testing.B) {
474 for b.Loop() {
475 _ = sets1.VectorSample().Distance(v1)
476 _ = sets1.VectorSample().Distance(v2)
477 }
478 })
479 }
480
481 func TestVectorStoreMap(t *testing.T) {
482 c := qt.New(t)
483 testDims := newTestDims()
484
485 c.Run("Complement", func(c *qt.C) {
486 v1 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
487 hmaps.NewOrderedIntSet(1, 3),
488 hmaps.NewOrderedIntSet(1),
489 hmaps.NewOrderedIntSet(1, 3),
490 ).Build()
491
492 m := v1.ToVectorStoreMap()
493
494 v2 := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
495 hmaps.NewOrderedIntSet(1, 2),
496 hmaps.NewOrderedIntSet(1),
497 hmaps.NewOrderedIntSet(1, 3),
498 ).Build()
499
500 complement := m.Complement(v2)
501
502 c.Assert(complement.Vectors(), qt.DeepEquals, []sitesmatrix.Vector{
503 {3, 1, 1},
504 {3, 1, 3},
505 })
506 })
507 }
508
509 func BenchmarkHasAnyVectorSingle(b *testing.B) {
510 testDims := newTestDims()
511 set := sitesmatrix.NewIntSetsBuilder(testDims).WithSets(
512 hmaps.NewOrderedIntSet(0),
513 hmaps.NewOrderedIntSet(0),
514 hmaps.NewOrderedIntSet(0),
515 ).Build()
516
517 v := sitesmatrix.Vector{0, 0, 0}
518
519 for b.Loop() {
520 _ = set.HasAnyVector(v)
521 }
522 }