Debian Codegraph @

v2/orderedmap_test.go

raw
1 package orderedmap_test
2
3 import (
4 "strconv"
5 "testing"
6
7 "github.com/elliotchance/orderedmap/v2"
8 "github.com/stretchr/testify/assert"
9 "github.com/stretchr/testify/require"
10 )
11
12 func TestNewOrderedMap(t *testing.T) {
13 m := orderedmap.NewOrderedMap[int, string]()
14 assert.IsType(t, &orderedmap.OrderedMap[int, string]{}, m)
15 }
16
17 func TestGet(t *testing.T) {
18 t.Run("ReturnsNotOKIfStringKeyDoesntExist", func(t *testing.T) {
19 m := orderedmap.NewOrderedMap[string, string]()
20 _, ok := m.Get("foo")
21 assert.False(t, ok)
22 })
23
24 t.Run("ReturnsNotOKIfNonStringKeyDoesntExist", func(t *testing.T) {
25 m := orderedmap.NewOrderedMap[int, string]()
26 _, ok := m.Get(123)
27 assert.False(t, ok)
28 })
29
30 t.Run("ReturnsOKIfKeyExists", func(t *testing.T) {
31 m := orderedmap.NewOrderedMap[string, string]()
32 m.Set("foo", "bar")
33 _, ok := m.Get("foo")
34 assert.True(t, ok)
35 })
36
37 t.Run("ReturnsValueForKey", func(t *testing.T) {
38 m := orderedmap.NewOrderedMap[string, string]()
39 m.Set("foo", "bar")
40 value, _ := m.Get("foo")
41 assert.Equal(t, "bar", value)
42 })
43
44 t.Run("ReturnsDynamicValueForKey", func(t *testing.T) {
45 m := orderedmap.NewOrderedMap[string, string]()
46 m.Set("foo", "baz")
47 value, _ := m.Get("foo")
48 assert.Equal(t, "baz", value)
49 })
50
51 t.Run("KeyDoesntExistOnNonEmptyMap", func(t *testing.T) {
52 m := orderedmap.NewOrderedMap[string, string]()
53 m.Set("foo", "baz")
54 _, ok := m.Get("bar")
55 assert.False(t, ok)
56 })
57
58 t.Run("ValueForKeyDoesntExistOnNonEmptyMap", func(t *testing.T) {
59 m := orderedmap.NewOrderedMap[string, string]()
60 m.Set("foo", "baz")
61 value, _ := m.Get("bar")
62 assert.Empty(t, value)
63 })
64 }
65
66 func TestSet(t *testing.T) {
67 t.Run("ReturnsTrueIfStringKeyIsNew", func(t *testing.T) {
68 m := orderedmap.NewOrderedMap[string, string]()
69 ok := m.Set("foo", "bar")
70 assert.True(t, ok)
71 })
72
73 t.Run("ReturnsTrueIfNonStringKeyIsNew", func(t *testing.T) {
74 m := orderedmap.NewOrderedMap[int, string]()
75 ok := m.Set(123, "bar")
76 assert.True(t, ok)
77 })
78
79 t.Run("ValueCanBeNonString", func(t *testing.T) {
80 m := orderedmap.NewOrderedMap[int, bool]()
81 ok := m.Set(123, true)
82 assert.True(t, ok)
83 })
84
85 t.Run("ReturnsFalseIfKeyIsNotNew", func(t *testing.T) {
86 m := orderedmap.NewOrderedMap[string, string]()
87 m.Set("foo", "bar")
88 ok := m.Set("foo", "bar")
89 assert.False(t, ok)
90 })
91
92 t.Run("SetThreeDifferentKeys", func(t *testing.T) {
93 m := orderedmap.NewOrderedMap[string, string]()
94 m.Set("foo", "bar")
95 m.Set("baz", "qux")
96 ok := m.Set("quux", "corge")
97 assert.True(t, ok)
98 })
99 }
100
101 func TestReplaceKey(t *testing.T) {
102 t.Run("ReturnsFalseIfOriginalKeyDoesntExist", func(t *testing.T) {
103 m := orderedmap.NewOrderedMap[string, string]()
104 assert.False(t, m.ReplaceKey("foo", "bar"))
105 })
106
107 t.Run("ReturnsFalseIfNewKeyAlreadyExists", func(t *testing.T) {
108 m := orderedmap.NewOrderedMap[string, string]()
109 m.Set("foo", "bar")
110 m.Set("baz", "qux")
111 assert.False(t, m.ReplaceKey("foo", "baz"))
112 assert.Equal(t, []string{"foo", "baz"}, m.Keys())
113 })
114
115 t.Run("ReturnsTrueIfOnlyOriginalKeyExists", func(t *testing.T) {
116 m := orderedmap.NewOrderedMap[string, string]()
117 m.Set("foo", "bar")
118 assert.True(t, m.ReplaceKey("foo", "baz"))
119
120 // Now validate the "replacement" was a success.
121 el := m.GetElement("baz")
122 require.NotNil(t, el)
123 assert.Equal(t, "bar", el.Value)
124 assert.Equal(t, "baz", el.Key)
125
126 v, ok := m.Get("baz")
127 assert.True(t, ok)
128 assert.Equal(t, "bar", v)
129 assert.Equal(t, []string{"baz"}, m.Keys())
130 assert.Equal(t, 1, m.Len())
131
132 _, ok = m.Get("foo") // original key
133 assert.False(t, ok)
134 })
135
136 t.Run("KeyMaintainsOrderWhenReplaced", func(t *testing.T) {
137 count := 100
138 // Build a larger map to help validate that the order is not coincidental.
139 m := orderedmap.NewOrderedMap[int, int]()
140 for i := 0; i < count; i++ {
141 m.Set(i, i)
142 }
143 // Rename the middle 50-60 elements to 100+ current
144 for i := 50; i < 60; i++ {
145 assert.True(t, m.ReplaceKey(i, i+100))
146 }
147
148 // ensure length is maintained
149 assert.Equal(t, count, m.Len())
150
151 // Validate the order is maintained.
152 keys := m.Keys()
153 for i, key := range keys {
154 if i >= 50 && i < 60 {
155 assert.Equal(t, i+100, key)
156 } else {
157 assert.Equal(t, i, key)
158 }
159 }
160 })
161 }
162
163 func TestLen(t *testing.T) {
164 t.Run("EmptyMapIsZeroLen", func(t *testing.T) {
165 m := orderedmap.NewOrderedMap[string, string]()
166 assert.Equal(t, 0, m.Len())
167 })
168
169 t.Run("SingleElementIsLenOne", func(t *testing.T) {
170 m := orderedmap.NewOrderedMap[int, bool]()
171 m.Set(123, true)
172 assert.Equal(t, 1, m.Len())
173 })
174
175 t.Run("ThreeElements", func(t *testing.T) {
176 m := orderedmap.NewOrderedMap[int, bool]()
177 m.Set(1, true)
178 m.Set(2, true)
179 m.Set(3, true)
180 assert.Equal(t, 3, m.Len())
181 })
182 }
183
184 func TestKeys(t *testing.T) {
185 t.Run("EmptyMap", func(t *testing.T) {
186 m := orderedmap.NewOrderedMap[int, bool]()
187 assert.Empty(t, m.Keys())
188 })
189
190 t.Run("OneElement", func(t *testing.T) {
191 m := orderedmap.NewOrderedMap[int, bool]()
192 m.Set(1, true)
193 assert.Equal(t, []int{1}, m.Keys())
194 })
195
196 t.Run("RetainsOrder", func(t *testing.T) {
197 m := orderedmap.NewOrderedMap[int, bool]()
198 for i := 1; i < 10; i++ {
199 m.Set(i, true)
200 }
201 assert.Equal(t,
202 []int{1, 2, 3, 4, 5, 6, 7, 8, 9},
203 m.Keys())
204 })
205
206 t.Run("ReplacingKeyDoesntChangeOrder", func(t *testing.T) {
207 m := orderedmap.NewOrderedMap[string, bool]()
208 m.Set("foo", true)
209 m.Set("bar", true)
210 m.Set("foo", false)
211 assert.Equal(t,
212 []string{"foo", "bar"},
213 m.Keys())
214 })
215
216 t.Run("KeysAfterDelete", func(t *testing.T) {
217 m := orderedmap.NewOrderedMap[string, bool]()
218 m.Set("foo", true)
219 m.Set("bar", true)
220 m.Delete("foo")
221 assert.Equal(t, []string{"bar"}, m.Keys())
222 })
223 }
224
225 func TestDelete(t *testing.T) {
226 t.Run("KeyDoesntExistReturnsFalse", func(t *testing.T) {
227 m := orderedmap.NewOrderedMap[string, string]()
228 assert.False(t, m.Delete("foo"))
229 })
230
231 t.Run("KeyDoesExist", func(t *testing.T) {
232 m := orderedmap.NewOrderedMap[string, any]()
233 m.Set("foo", nil)
234 assert.True(t, m.Delete("foo"))
235 })
236
237 t.Run("KeyNoLongerExists", func(t *testing.T) {
238 m := orderedmap.NewOrderedMap[string, any]()
239 m.Set("foo", nil)
240 m.Delete("foo")
241 _, exists := m.Get("foo")
242 assert.False(t, exists)
243 })
244
245 t.Run("KeyDeleteIsIsolated", func(t *testing.T) {
246 m := orderedmap.NewOrderedMap[string, any]()
247 m.Set("foo", nil)
248 m.Set("bar", nil)
249 m.Delete("foo")
250 _, exists := m.Get("bar")
251 assert.True(t, exists)
252 })
253 }
254
255 func TestOrderedMap_Front(t *testing.T) {
256 t.Run("NilOnEmptyMap", func(t *testing.T) {
257 m := orderedmap.NewOrderedMap[int, bool]()
258 assert.Nil(t, m.Front())
259 })
260
261 t.Run("NilOnEmptyMap", func(t *testing.T) {
262 m := orderedmap.NewOrderedMap[int, bool]()
263 m.Set(1, true)
264 assert.NotNil(t, m.Front())
265 })
266 }
267
268 func TestOrderedMap_Back(t *testing.T) {
269 t.Run("NilOnEmptyMap", func(t *testing.T) {
270 m := orderedmap.NewOrderedMap[int, bool]()
271 assert.Nil(t, m.Back())
272 })
273
274 t.Run("NilOnEmptyMap", func(t *testing.T) {
275 m := orderedmap.NewOrderedMap[int, bool]()
276 m.Set(1, true)
277 assert.NotNil(t, m.Back())
278 })
279 }
280
281 func TestOrderedMap_Copy(t *testing.T) {
282 t.Run("ReturnsEqualButNotSame", func(t *testing.T) {
283 key, value := 1, "a value"
284 m := orderedmap.NewOrderedMap[int, string]()
285 m.Set(key, value)
286
287 m2 := m.Copy()
288 m2.Set(key, "a different value")
289
290 assert.Equal(t, m.Len(), m2.Len(), "not all elements are copied")
291 assert.Equal(t, value, m.GetElement(key).Value)
292 })
293 }
294
295 func TestGetElement(t *testing.T) {
296 t.Run("ReturnsElementForKey", func(t *testing.T) {
297 m := orderedmap.NewOrderedMap[string, string]()
298 m.Set("foo", "bar")
299
300 var results []any
301 element := m.GetElement("foo")
302 if element != nil {
303 results = append(results, element.Key, element.Value)
304 }
305
306 assert.Equal(t, []any{"foo", "bar"}, results)
307 })
308
309 t.Run("ElementForKeyDoesntExistOnNonEmptyMap", func(t *testing.T) {
310 m := orderedmap.NewOrderedMap[string, string]()
311 m.Set("foo", "baz")
312 element := m.GetElement("bar")
313 assert.Nil(t, element)
314 })
315 }
316
317 func TestSetAndGet(t *testing.T) {
318 t.Run("FourBoolElements", func(t *testing.T) {
319 m := orderedmap.NewOrderedMap[int, bool]()
320 expected := map[int]bool{1: true, 3: false, 5: false, 4: true}
321 for k, v := range expected {
322 m.Set(k, v)
323 }
324 for k, v := range expected {
325 w, ok := m.Get(k)
326 assert.True(t, ok)
327 assert.Equal(t, v, w)
328 }
329 })
330 }
331
332 func TestIterations(t *testing.T) {
333 type Element struct {
334 Key int
335 Value bool
336 }
337 t.Run("FourBoolElements", func(t *testing.T) {
338 m := orderedmap.NewOrderedMap[int, bool]()
339 expected := []Element{{5, true}, {3, false}, {1, false}, {4, true}}
340 for _, v := range expected {
341 m.Set(v.Key, v.Value)
342 }
343 element := m.Front()
344 for i := 0; i < len(expected); i++ {
345 assert.NotNil(t, element)
346 assert.Equal(t, expected[i].Key, element.Key)
347 assert.Equal(t, expected[i].Value, element.Value)
348 element = element.Next()
349 }
350 assert.Nil(t, element)
351 })
352 }
353
354 func TestOrderedMap_Has(t *testing.T) {
355 t.Run("ReturnsFalseIfKeyDoesNotExist", func(t *testing.T) {
356 m := orderedmap.NewOrderedMap[string, string]()
357 assert.False(t, m.Has("foo"))
358 })
359
360 t.Run("ReturnsTrueIfKeyExists", func(t *testing.T) {
361 m := orderedmap.NewOrderedMap[string, string]()
362 m.Set("foo", "bar")
363 assert.True(t, m.Has("foo"))
364 })
365
366 t.Run("KeyDoesNotExistAfterDelete", func(t *testing.T) {
367 m := orderedmap.NewOrderedMap[string, string]()
368 m.Set("foo", "bar")
369 m.Delete("foo")
370 assert.False(t, m.Has("foo"))
371 })
372 }
373
374 func benchmarkMap_Set(multiplier int) func(b *testing.B) {
375 return func(b *testing.B) {
376 m := make(map[int]bool)
377 for i := 0; i < b.N*multiplier; i++ {
378 m[i] = true
379 }
380 }
381 }
382
383 func BenchmarkMap_Set(b *testing.B) {
384 benchmarkMap_Set(1)(b)
385 }
386
387 func benchmarkOrderedMap_Set(multiplier int) func(b *testing.B) {
388 return func(b *testing.B) {
389 m := orderedmap.NewOrderedMap[int, bool]()
390 for i := 0; i < b.N*multiplier; i++ {
391 m.Set(i, true)
392 }
393 }
394 }
395
396 func BenchmarkOrderedMap_Set(b *testing.B) {
397 benchmarkOrderedMap_Set(1)(b)
398 }
399
400 func benchmarkMap_Get(multiplier int) func(b *testing.B) {
401 m := make(map[int]bool)
402 for i := 0; i < 1000*multiplier; i++ {
403 m[i] = true
404 }
405
406 return func(b *testing.B) {
407 for i := 0; i < b.N; i++ {
408 _ = m[i%1000*multiplier]
409 }
410 }
411 }
412
413 func BenchmarkMap_Get(b *testing.B) {
414 benchmarkMap_Get(1)(b)
415 }
416
417 func benchmarkOrderedMap_Get(multiplier int) func(b *testing.B) {
418 m := orderedmap.NewOrderedMap[int, bool]()
419 for i := 0; i < 1000*multiplier; i++ {
420 m.Set(i, true)
421 }
422
423 return func(b *testing.B) {
424 for i := 0; i < b.N; i++ {
425 m.Get(i % 1000 * multiplier)
426 }
427 }
428 }
429
430 func BenchmarkOrderedMap_Get(b *testing.B) {
431 benchmarkOrderedMap_Get(1)(b)
432 }
433
434 func benchmarkOrderedMap_GetElement(multiplier int) func(b *testing.B) {
435 m := orderedmap.NewOrderedMap[int, bool]()
436 for i := 0; i < 1000*multiplier; i++ {
437 m.Set(i, true)
438 }
439
440 return func(b *testing.B) {
441 for i := 0; i < b.N; i++ {
442 m.GetElement(i % 1000 * multiplier)
443 }
444 }
445 }
446
447 func BenchmarkOrderedMap_GetElement(b *testing.B) {
448 benchmarkOrderedMap_GetElement(1)(b)
449 }
450
451 var tempInt int
452
453 func benchmarkOrderedMap_Len(multiplier int) func(b *testing.B) {
454 m := orderedmap.NewOrderedMap[int, bool]()
455 for i := 0; i < 1000*multiplier; i++ {
456 m.Set(i, true)
457 }
458
459 return func(b *testing.B) {
460 var temp int
461 for i := 0; i < b.N; i++ {
462 temp = m.Len()
463 }
464
465 // prevent compiler from optimising Len away.
466 tempInt = temp
467 }
468 }
469
470 func BenchmarkOrderedMap_Len(b *testing.B) {
471 benchmarkOrderedMap_Len(1)(b)
472 }
473
474 func benchmarkMap_Delete(multiplier int) func(b *testing.B) {
475 return func(b *testing.B) {
476 m := make(map[int]bool)
477 for i := 0; i < b.N*multiplier; i++ {
478 m[i] = true
479 }
480
481 for i := 0; i < b.N; i++ {
482 delete(m, i)
483 }
484 }
485 }
486
487 func BenchmarkMap_Delete(b *testing.B) {
488 benchmarkMap_Delete(1)(b)
489 }
490
491 func benchmarkOrderedMap_Delete(multiplier int) func(b *testing.B) {
492 return func(b *testing.B) {
493 m := orderedmap.NewOrderedMap[int, bool]()
494 for i := 0; i < b.N*multiplier; i++ {
495 m.Set(i, true)
496 }
497
498 for i := 0; i < b.N; i++ {
499 m.Delete(i)
500 }
501 }
502 }
503
504 func BenchmarkOrderedMap_Delete(b *testing.B) {
505 benchmarkOrderedMap_Delete(1)(b)
506 }
507
508 func benchmarkMap_Iterate(multiplier int) func(b *testing.B) {
509 m := make(map[int]bool)
510 for i := 0; i < 1000*multiplier; i++ {
511 m[i] = true
512 }
513 return func(b *testing.B) {
514 for i := 0; i < b.N; i++ {
515 for _, v := range m {
516 nothing(v)
517 }
518 }
519 }
520 }
521 func BenchmarkMap_Iterate(b *testing.B) {
522 benchmarkMap_Iterate(1)(b)
523 }
524
525 func benchmarkOrderedMap_Iterate(multiplier int) func(b *testing.B) {
526 m := orderedmap.NewOrderedMap[int, bool]()
527 for i := 0; i < 1000*multiplier; i++ {
528 m.Set(i, true)
529 }
530
531 return func(b *testing.B) {
532 for i := 0; i < b.N; i++ {
533 for _, key := range m.Keys() {
534 _, v := m.Get(key)
535 nothing(v)
536 }
537 }
538 }
539 }
540
541 func BenchmarkOrderedMap_Iterate(b *testing.B) {
542 benchmarkOrderedMap_Iterate(1)(b)
543 }
544
545 func benchmarkMap_Has(multiplier int) func(b *testing.B) {
546 m := make(map[int]bool)
547 for i := 0; i < 1000*multiplier; i++ {
548 m[i] = true
549 }
550
551 return func(b *testing.B) {
552 for i := 0; i < b.N; i++ {
553 _ = m[i%1000*multiplier]
554 }
555 }
556 }
557
558 func BenchmarkMap_Has(b *testing.B) {
559 benchmarkMap_Has(1)(b)
560 }
561
562 func benchmarkOrderedMap_Has(multiplier int) func(b *testing.B) {
563 m := orderedmap.NewOrderedMap[int, bool]()
564 for i := 0; i < 1000*multiplier; i++ {
565 m.Set(i, true)
566 }
567 return func(b *testing.B) {
568 for i := 0; i < b.N; i++ {
569 m.Has(i % 1000 * multiplier)
570 }
571 }
572 }
573
574 func BenchmarkOrderedMap_Has(b *testing.B) {
575 benchmarkOrderedMap_Has(1)(b)
576 }
577
578 func benchmarkOrderedMap_Keys(multiplier int) func(b *testing.B) {
579 m := orderedmap.NewOrderedMap[int, bool]()
580 for i := 0; i < 1000*multiplier; i++ {
581 m.Set(i, true)
582 }
583
584 return func(b *testing.B) {
585 for i := 0; i < b.N; i++ {
586 m.Keys()
587 }
588 }
589 }
590
591 func benchmarkMapString_Set(multiplier int) func(b *testing.B) {
592 return func(b *testing.B) {
593 m := make(map[string]bool)
594 a := "12345678"
595 for i := 0; i < b.N*multiplier; i++ {
596 m[a+strconv.Itoa(i)] = true
597 }
598 }
599 }
600
601 func BenchmarkMapString_Set(b *testing.B) {
602 benchmarkMapString_Set(1)(b)
603 }
604
605 func benchmarkOrderedMapString_Set(multiplier int) func(b *testing.B) {
606 return func(b *testing.B) {
607 m := orderedmap.NewOrderedMap[string, bool]()
608 a := "12345678"
609 for i := 0; i < b.N*multiplier; i++ {
610 m.Set(a+strconv.Itoa(i), true)
611 }
612 }
613 }
614
615 func BenchmarkOrderedMapString_Set(b *testing.B) {
616 benchmarkOrderedMapString_Set(1)(b)
617 }
618
619 func benchmarkMapString_Get(multiplier int) func(b *testing.B) {
620 m := make(map[string]bool)
621 a := "12345678"
622 for i := 0; i < 1000*multiplier; i++ {
623 m[a+strconv.Itoa(i)] = true
624 }
625
626 return func(b *testing.B) {
627 for i := 0; i < b.N; i++ {
628 _ = m[a+strconv.Itoa(i%1000*multiplier)]
629 }
630 }
631 }
632
633 func BenchmarkMapString_Get(b *testing.B) {
634 benchmarkMapString_Get(1)(b)
635 }
636
637 func benchmarkOrderedMapString_Get(multiplier int) func(b *testing.B) {
638 m := orderedmap.NewOrderedMap[string, bool]()
639 a := "12345678"
640 for i := 0; i < 1000*multiplier; i++ {
641 m.Set(a+strconv.Itoa(i), true)
642 }
643
644 return func(b *testing.B) {
645 for i := 0; i < b.N; i++ {
646 m.Get(a + strconv.Itoa(i%1000*multiplier))
647 }
648 }
649 }
650
651 func BenchmarkOrderedMapString_Get(b *testing.B) {
652 benchmarkOrderedMapString_Get(1)(b)
653 }
654
655 func benchmarkOrderedMapString_GetElement(multiplier int) func(b *testing.B) {
656 m := orderedmap.NewOrderedMap[string, bool]()
657 a := "12345678"
658 for i := 0; i < 1000*multiplier; i++ {
659 m.Set(a+strconv.Itoa(i), true)
660 }
661
662 return func(b *testing.B) {
663 for i := 0; i < b.N; i++ {
664 m.GetElement(a + strconv.Itoa(i%1000*multiplier))
665 }
666 }
667 }
668
669 func BenchmarkOrderedMapString_GetElement(b *testing.B) {
670 benchmarkOrderedMapString_GetElement(1)(b)
671 }
672
673 func benchmarkMapString_Delete(multiplier int) func(b *testing.B) {
674 return func(b *testing.B) {
675 m := make(map[string]bool)
676 a := "12345678"
677 for i := 0; i < b.N*multiplier; i++ {
678 m[a+strconv.Itoa(i)] = true
679 }
680
681 for i := 0; i < b.N; i++ {
682 delete(m, a+strconv.Itoa(i))
683 }
684 }
685 }
686
687 func BenchmarkMapString_Delete(b *testing.B) {
688 benchmarkMapString_Delete(1)(b)
689 }
690
691 func benchmarkOrderedMapString_Delete(multiplier int) func(b *testing.B) {
692 return func(b *testing.B) {
693 m := orderedmap.NewOrderedMap[string, bool]()
694 a := "12345678"
695 for i := 0; i < b.N*multiplier; i++ {
696 m.Set(a+strconv.Itoa(i), true)
697 }
698
699 for i := 0; i < b.N; i++ {
700 m.Delete(a + strconv.Itoa(i))
701 }
702 }
703 }
704
705 func BenchmarkOrderedMapString_Delete(b *testing.B) {
706 benchmarkOrderedMapString_Delete(1)(b)
707 }
708
709 func benchmarkMapString_Iterate(multiplier int) func(b *testing.B) {
710 m := make(map[string]bool)
711 a := "12345678"
712 for i := 0; i < 1000*multiplier; i++ {
713 m[a+strconv.Itoa(i)] = true
714 }
715 return func(b *testing.B) {
716 for i := 0; i < b.N; i++ {
717 for _, v := range m {
718 nothing(v)
719 }
720 }
721 }
722 }
723 func BenchmarkMapString_Iterate(b *testing.B) {
724 benchmarkMapString_Iterate(1)(b)
725 }
726
727 func benchmarkOrderedMapString_Iterate(multiplier int) func(b *testing.B) {
728 m := orderedmap.NewOrderedMap[string, bool]()
729 a := "12345678"
730 for i := 0; i < 1000*multiplier; i++ {
731 m.Set(a+strconv.Itoa(i), true)
732 }
733
734 return func(b *testing.B) {
735 for i := 0; i < b.N; i++ {
736 for _, key := range m.Keys() {
737 _, v := m.Get(key)
738 nothing(v)
739 }
740 }
741 }
742 }
743
744 func BenchmarkOrderedMapString_Iterate(b *testing.B) {
745 benchmarkOrderedMapString_Iterate(1)(b)
746 }
747
748 func benchmarkMapString_Has(multiplier int) func(b *testing.B) {
749 m := make(map[string]bool)
750 a := "12345678"
751 for i := 0; i < 1000*multiplier; i++ {
752 m[a+strconv.Itoa(i)] = true
753 }
754 return func(b *testing.B) {
755 for i := 0; i < b.N; i++ {
756 _ = m[a+strconv.Itoa(i%1000*multiplier)]
757 }
758 }
759 }
760
761 func BenchmarkMapString_Has(b *testing.B) {
762 benchmarkMapString_Has(1)(b)
763 }
764
765 func benchmarkOrderedMapString_Has(multiplier int) func(b *testing.B) {
766 m := orderedmap.NewOrderedMap[string, bool]()
767 a := "12345678"
768 for i := 0; i < 1000*multiplier; i++ {
769 m.Set(a+strconv.Itoa(i), true)
770 }
771 return func(b *testing.B) {
772 for i := 0; i < b.N; i++ {
773 m.Has(a + strconv.Itoa(i%1000*multiplier))
774 }
775 }
776 }
777
778 func BenchmarkOrderedMapString_Has(b *testing.B) {
779 benchmarkOrderedMapString_Has(1)(b)
780 }
781
782 func BenchmarkOrderedMap_Keys(b *testing.B) {
783 benchmarkOrderedMap_Keys(1)(b)
784 }
785
786 func nothing(v interface{}) {
787 v = false
788 }
789
790 func benchmarkBigMap_Set() func(b *testing.B) {
791 return func(b *testing.B) {
792 for j := 0; j < b.N; j++ {
793 m := make(map[int]bool)
794 for i := 0; i < 10000000; i++ {
795 m[i] = true
796 }
797 }
798 }
799 }
800
801 func BenchmarkBigMap_Set(b *testing.B) {
802 benchmarkBigMap_Set()(b)
803 }
804
805 func benchmarkBigOrderedMap_Set() func(b *testing.B) {
806 return func(b *testing.B) {
807 for j := 0; j < b.N; j++ {
808 m := orderedmap.NewOrderedMap[int, bool]()
809 for i := 0; i < 10000000; i++ {
810 m.Set(i, true)
811 }
812 }
813 }
814 }
815
816 func BenchmarkBigOrderedMap_Set(b *testing.B) {
817 benchmarkBigOrderedMap_Set()(b)
818 }
819
820 func benchmarkBigMapWithCapacity_Set() func(b *testing.B) {
821 return func(b *testing.B) {
822 for j := 0; j < b.N; j++ {
823 m := orderedmap.NewOrderedMapWithCapacity[int, bool](10000000)
824 for i := 0; i < 10000000; i++ {
825 m.Set(i, true)
826 }
827 }
828 }
829 }
830
831 func BenchmarkBigMapWithCapacity_Set(b *testing.B) {
832 benchmarkBigMapWithCapacity_Set()(b)
833 }
834
835 func benchmarkBigMap_Get() func(b *testing.B) {
836 m := make(map[int]bool)
837 for i := 0; i < 10000000; i++ {
838 m[i] = true
839 }
840
841 return func(b *testing.B) {
842 for j := 0; j < b.N; j++ {
843 for i := 0; i < 10000000; i++ {
844 _ = m[i]
845 }
846 }
847 }
848 }
849
850 func BenchmarkBigMap_Get(b *testing.B) {
851 benchmarkBigMap_Get()(b)
852 }
853
854 func benchmarkBigOrderedMap_Get() func(b *testing.B) {
855 m := orderedmap.NewOrderedMap[int, bool]()
856 for i := 0; i < 10000000; i++ {
857 m.Set(i, true)
858 }
859
860 return func(b *testing.B) {
861 for j := 0; j < b.N; j++ {
862 for i := 0; i < 10000000; i++ {
863 m.Get(i)
864 }
865 }
866 }
867 }
868
869 func BenchmarkBigOrderedMap_Get(b *testing.B) {
870 benchmarkBigOrderedMap_Get()(b)
871 }
872
873 func benchmarkBigOrderedMap_GetElement() func(b *testing.B) {
874 m := orderedmap.NewOrderedMap[int, bool]()
875 for i := 0; i < 10000000; i++ {
876 m.Set(i, true)
877 }
878
879 return func(b *testing.B) {
880 for j := 0; j < b.N; j++ {
881 for i := 0; i < 10000000; i++ {
882 m.GetElement(i)
883 }
884 }
885 }
886 }
887
888 func BenchmarkBigOrderedMap_GetElement(b *testing.B) {
889 benchmarkBigOrderedMap_GetElement()(b)
890 }
891
892 func benchmarkBigMap_Iterate() func(b *testing.B) {
893 m := make(map[int]bool)
894 for i := 0; i < 10000000; i++ {
895 m[i] = true
896 }
897 return func(b *testing.B) {
898 for i := 0; i < b.N; i++ {
899 for _, v := range m {
900 nothing(v)
901 }
902 }
903 }
904 }
905 func BenchmarkBigMap_Iterate(b *testing.B) {
906 benchmarkBigMap_Iterate()(b)
907 }
908
909 func benchmarkBigOrderedMap_Iterate() func(b *testing.B) {
910 m := orderedmap.NewOrderedMap[int, bool]()
911 for i := 0; i < 10000000; i++ {
912 m.Set(i, true)
913 }
914
915 return func(b *testing.B) {
916 for i := 0; i < b.N; i++ {
917 for _, key := range m.Keys() {
918 _, v := m.Get(key)
919 nothing(v)
920 }
921 }
922 }
923 }
924
925 func BenchmarkBigOrderedMap_Iterate(b *testing.B) {
926 benchmarkBigOrderedMap_Iterate()(b)
927 }
928
929 func benchmarkBigMapString_Set() func(b *testing.B) {
930 return func(b *testing.B) {
931 for j := 0; j < b.N; j++ {
932 m := make(map[string]bool)
933 a := "1234567"
934 for i := 0; i < 10000000; i++ {
935 m[a+strconv.Itoa(i)] = true
936 }
937 }
938 }
939 }
940
941 func benchmarkBigMap_Has() func(b *testing.B) {
942 m := make(map[int]bool)
943 for i := 0; i < 10000000; i++ {
944 m[i] = true
945 }
946 return func(b *testing.B) {
947 for j := 0; j < b.N; j++ {
948 for i := 0; i < 10000000; i++ {
949 _ = m[i]
950 }
951 }
952 }
953 }
954
955 func BenchmarkBigMap_Has(b *testing.B) {
956 benchmarkBigMap_Has()(b)
957 }
958
959 func benchmarkBigOrderedMap_Has() func(b *testing.B) {
960 m := orderedmap.NewOrderedMap[int, bool]()
961 for i := 0; i < 10000000; i++ {
962 m.Set(i, true)
963 }
964 return func(b *testing.B) {
965 for j := 0; j < b.N; j++ {
966 for i := 0; i < 10000000; i++ {
967 m.Has(i)
968 }
969 }
970 }
971 }
972
973 func BenchmarkBigOrderedMap_Has(b *testing.B) {
974 benchmarkBigOrderedMap_Has()(b)
975 }
976
977 func BenchmarkBigMapString_Set(b *testing.B) {
978 benchmarkBigMapString_Set()(b)
979 }
980
981 func benchmarkBigOrderedMapString_Set() func(b *testing.B) {
982 return func(b *testing.B) {
983 for j := 0; j < b.N; j++ {
984 m := orderedmap.NewOrderedMap[string, bool]()
985 a := "1234567"
986 for i := 0; i < 10000000; i++ {
987 m.Set(a+strconv.Itoa(i), true)
988 }
989 }
990 }
991 }
992
993 func BenchmarkBigOrderedMapString_Set(b *testing.B) {
994 benchmarkBigOrderedMapString_Set()(b)
995 }
996
997 func benchmarkBigMapString_Get() func(b *testing.B) {
998 m := make(map[string]bool)
999 a := "1234567"
1000 for i := 0; i < 10000000; i++ {
1001 m[a+strconv.Itoa(i)] = true
1002 }
1003
1004 return func(b *testing.B) {
1005 for j := 0; j < b.N; j++ {
1006 for i := 0; i < 10000000; i++ {
1007 _ = m[a+strconv.Itoa(i)]
1008 }
1009 }
1010 }
1011 }
1012
1013 func BenchmarkBigMapString_Get(b *testing.B) {
1014 benchmarkBigMapString_Get()(b)
1015 }
1016
1017 func benchmarkBigOrderedMapString_Get() func(b *testing.B) {
1018 m := orderedmap.NewOrderedMap[string, bool]()
1019 a := "1234567"
1020 for i := 0; i < 10000000; i++ {
1021 m.Set(a+strconv.Itoa(i), true)
1022 }
1023
1024 return func(b *testing.B) {
1025 for j := 0; j < b.N; j++ {
1026 for i := 0; i < 10000000; i++ {
1027 m.Get(a + strconv.Itoa(i))
1028 }
1029 }
1030 }
1031 }
1032
1033 func BenchmarkBigOrderedMapString_Get(b *testing.B) {
1034 benchmarkBigOrderedMapString_Get()(b)
1035 }
1036
1037 func benchmarkBigOrderedMapString_GetElement() func(b *testing.B) {
1038 m := orderedmap.NewOrderedMap[string, bool]()
1039 a := "1234567"
1040 for i := 0; i < 10000000; i++ {
1041 m.Set(a+strconv.Itoa(i), true)
1042 }
1043
1044 return func(b *testing.B) {
1045 for j := 0; j < b.N; j++ {
1046 for i := 0; i < 10000000; i++ {
1047 m.GetElement(a + strconv.Itoa(i))
1048 }
1049 }
1050 }
1051 }
1052
1053 func BenchmarkBigOrderedMapString_GetElement(b *testing.B) {
1054 benchmarkBigOrderedMapString_GetElement()(b)
1055 }
1056
1057 func benchmarkBigMapString_Iterate() func(b *testing.B) {
1058 m := make(map[string]bool)
1059 a := "12345678"
1060 for i := 0; i < 10000000; i++ {
1061 m[a+strconv.Itoa(i)] = true
1062 }
1063 return func(b *testing.B) {
1064 for i := 0; i < b.N; i++ {
1065 for _, v := range m {
1066 nothing(v)
1067 }
1068 }
1069 }
1070 }
1071 func BenchmarkBigMapString_Iterate(b *testing.B) {
1072 benchmarkBigMapString_Iterate()(b)
1073 }
1074
1075 func benchmarkBigOrderedMapString_Iterate() func(b *testing.B) {
1076 m := orderedmap.NewOrderedMap[string, bool]()
1077 a := "12345678"
1078 for i := 0; i < 10000000; i++ {
1079 m.Set(a+strconv.Itoa(i), true)
1080 }
1081
1082 return func(b *testing.B) {
1083 for i := 0; i < b.N; i++ {
1084 for _, key := range m.Keys() {
1085 _, v := m.Get(key)
1086 nothing(v)
1087 }
1088 }
1089 }
1090 }
1091
1092 func BenchmarkBigOrderedMapString_Iterate(b *testing.B) {
1093 benchmarkBigOrderedMapString_Iterate()(b)
1094 }
1095
1096 func benchmarkBigMapString_Has() func(b *testing.B) {
1097 m := make(map[string]bool)
1098 a := "12345678"
1099 for i := 0; i < 10000000; i++ {
1100 m[a+strconv.Itoa(i)] = true
1101 }
1102 return func(b *testing.B) {
1103 for j := 0; j < b.N; j++ {
1104 for i := 0; i < 10000000; i++ {
1105 _ = m[a+strconv.Itoa(i)]
1106 }
1107 }
1108 }
1109 }
1110
1111 func BenchmarkBigMapString_Has(b *testing.B) {
1112 benchmarkBigMapString_Has()(b)
1113 }
1114
1115 func benchmarkBigOrderedMapString_Has() func(b *testing.B) {
1116 m := orderedmap.NewOrderedMap[string, bool]()
1117 a := "12345678"
1118 for i := 0; i < 10000000; i++ {
1119 m.Set(a+strconv.Itoa(i), true)
1120 }
1121 return func(b *testing.B) {
1122 for j := 0; j < b.N; j++ {
1123 for i := 0; i < 10000000; i++ {
1124 m.Has(a + strconv.Itoa(i))
1125 }
1126 }
1127 }
1128 }
1129
1130 func BenchmarkBigOrderedMapString_Has(b *testing.B) {
1131 benchmarkBigOrderedMapString_Has()(b)
1132 }
1133
1134 func BenchmarkAll(b *testing.B) {
1135 b.Run("BenchmarkOrderedMap_Keys", BenchmarkOrderedMap_Keys)
1136
1137 b.Run("BenchmarkOrderedMap_Set", BenchmarkOrderedMap_Set)
1138 b.Run("BenchmarkMap_Set", BenchmarkMap_Set)
1139 b.Run("BenchmarkOrderedMap_Get", BenchmarkOrderedMap_Get)
1140 b.Run("BenchmarkMap_Get", BenchmarkMap_Get)
1141 b.Run("BenchmarkOrderedMap_GetElement", BenchmarkOrderedMap_GetElement)
1142 b.Run("BenchmarkOrderedMap_Delete", BenchmarkOrderedMap_Delete)
1143 b.Run("BenchmarkMap_Delete", BenchmarkMap_Delete)
1144 b.Run("BenchmarkOrderedMap_Iterate", BenchmarkOrderedMap_Iterate)
1145 b.Run("BenchmarkMap_Iterate", BenchmarkMap_Iterate)
1146 b.Run("BenchmarkOrderedMap_Has", BenchmarkOrderedMap_Has)
1147 b.Run("BenchmarkMap_Has", BenchmarkMap_Has)
1148
1149 b.Run("BenchmarkBigMap_Set", BenchmarkBigMap_Set)
1150 b.Run("BenchmarkBigOrderedMap_Set", BenchmarkBigOrderedMap_Set)
1151 b.Run("BenchmarkBigMap_Get", BenchmarkBigMap_Get)
1152 b.Run("BenchmarkBigOrderedMap_Get", BenchmarkBigOrderedMap_Get)
1153 b.Run("BenchmarkBigOrderedMap_GetElement",
1154 BenchmarkBigOrderedMap_GetElement)
1155 b.Run("BenchmarkBigOrderedMap_Iterate", BenchmarkBigOrderedMap_Iterate)
1156 b.Run("BenchmarkBigMap_Iterate", BenchmarkBigMap_Iterate)
1157 b.Run("BenchmarkBigMap_Has", BenchmarkBigMap_Has)
1158 b.Run("BenchmarkBigOrderedMap_Has", BenchmarkBigOrderedMap_Has)
1159
1160 b.Run("BenchmarkOrderedMapString_Set", BenchmarkOrderedMapString_Set)
1161 b.Run("BenchmarkMapString_Set", BenchmarkMapString_Set)
1162 b.Run("BenchmarkOrderedMapString_Get", BenchmarkOrderedMapString_Get)
1163 b.Run("BenchmarkMapString_Get", BenchmarkMapString_Get)
1164 b.Run("BenchmarkOrderedMapString_GetElement",
1165 BenchmarkOrderedMapString_GetElement)
1166 b.Run("BenchmarkOrderedMapString_Delete", BenchmarkOrderedMapString_Delete)
1167 b.Run("BenchmarkMapString_Delete", BenchmarkMapString_Delete)
1168 b.Run("BenchmarkOrderedMapString_Iterate",
1169 BenchmarkOrderedMapString_Iterate)
1170 b.Run("BenchmarkMapString_Iterate", BenchmarkMapString_Iterate)
1171 b.Run("BenchmarkMapString_Has", BenchmarkMapString_Has)
1172 b.Run("BenchmarkOrderedMapString_Has", BenchmarkOrderedMapString_Has)
1173
1174 b.Run("BenchmarkBigMapString_Set", BenchmarkBigMapString_Set)
1175 b.Run("BenchmarkBigOrderedMapString_Set", BenchmarkBigOrderedMapString_Set)
1176 b.Run("BenchmarkBigMapString_Get", BenchmarkBigMapString_Get)
1177 b.Run("BenchmarkBigOrderedMapString_Get", BenchmarkBigOrderedMapString_Get)
1178 b.Run("BenchmarkBigOrderedMapString_GetElement",
1179 BenchmarkBigOrderedMapString_GetElement)
1180 b.Run("BenchmarkBigOrderedMapString_Iterate",
1181 BenchmarkBigOrderedMapString_Iterate)
1182 b.Run("BenchmarkBigMapString_Iterate", BenchmarkBigMapString_Iterate)
1183 b.Run("BenchmarkBigMapString_Has", BenchmarkBigMapString_Has)
1184 b.Run("BenchmarkBigOrderedMapString_Has", BenchmarkBigOrderedMapString_Has)
1185 }