1package mapset
2
3import (
4	"math/rand"
5	"testing"
6)
7
8func nrand(n int) []int {
9	i := make([]int, n)
10	for ind := range i {
11		i[ind] = rand.Int()
12	}
13	return i
14}
15
16func toInterfaces(i []int) []interface{} {
17	ifs := make([]interface{}, len(i))
18	for ind, v := range i {
19		ifs[ind] = v
20	}
21	return ifs
22}
23
24func benchAdd(b *testing.B, s Set) {
25	nums := nrand(b.N)
26	b.ResetTimer()
27	for _, v := range nums {
28		s.Add(v)
29	}
30}
31
32func BenchmarkAddSafe(b *testing.B) {
33	benchAdd(b, NewSet())
34}
35
36func BenchmarkAddUnsafe(b *testing.B) {
37	benchAdd(b, NewThreadUnsafeSet())
38}
39
40func benchRemove(b *testing.B, s Set) {
41	nums := nrand(b.N)
42	for _, v := range nums {
43		s.Add(v)
44	}
45
46	b.ResetTimer()
47	for _, v := range nums {
48		s.Remove(v)
49	}
50}
51
52func BenchmarkRemoveSafe(b *testing.B) {
53	benchRemove(b, NewSet())
54}
55
56func BenchmarkRemoveUnsafe(b *testing.B) {
57	benchRemove(b, NewThreadUnsafeSet())
58}
59
60func benchCardinality(b *testing.B, s Set) {
61	for i := 0; i < b.N; i++ {
62		s.Cardinality()
63	}
64}
65
66func BenchmarkCardinalitySafe(b *testing.B) {
67	benchCardinality(b, NewSet())
68}
69
70func BenchmarkCardinalityUnsafe(b *testing.B) {
71	benchCardinality(b, NewThreadUnsafeSet())
72}
73
74func benchClear(b *testing.B, s Set) {
75	b.ResetTimer()
76	for i := 0; i < b.N; i++ {
77		s.Clear()
78	}
79}
80
81func BenchmarkClearSafe(b *testing.B) {
82	benchClear(b, NewSet())
83}
84
85func BenchmarkClearUnsafe(b *testing.B) {
86	benchClear(b, NewThreadUnsafeSet())
87}
88
89func benchClone(b *testing.B, n int, s Set) {
90	nums := toInterfaces(nrand(n))
91	for _, v := range nums {
92		s.Add(v)
93	}
94
95	b.ResetTimer()
96	for i := 0; i < b.N; i++ {
97		s.Clone()
98	}
99}
100
101func BenchmarkClone1Safe(b *testing.B) {
102	benchClone(b, 1, NewSet())
103}
104
105func BenchmarkClone1Unsafe(b *testing.B) {
106	benchClone(b, 1, NewThreadUnsafeSet())
107}
108
109func BenchmarkClone10Safe(b *testing.B) {
110	benchClone(b, 10, NewSet())
111}
112
113func BenchmarkClone10Unsafe(b *testing.B) {
114	benchClone(b, 10, NewThreadUnsafeSet())
115}
116
117func BenchmarkClone100Safe(b *testing.B) {
118	benchClone(b, 100, NewSet())
119}
120
121func BenchmarkClone100Unsafe(b *testing.B) {
122	benchClone(b, 100, NewThreadUnsafeSet())
123}
124
125func benchContains(b *testing.B, n int, s Set) {
126	nums := toInterfaces(nrand(n))
127	for _, v := range nums {
128		s.Add(v)
129	}
130
131	nums[n-1] = -1 // Definitely not in s
132
133	b.ResetTimer()
134	for i := 0; i < b.N; i++ {
135		s.Contains(nums...)
136	}
137}
138
139func BenchmarkContains1Safe(b *testing.B) {
140	benchContains(b, 1, NewSet())
141}
142
143func BenchmarkContains1Unsafe(b *testing.B) {
144	benchContains(b, 1, NewThreadUnsafeSet())
145}
146
147func BenchmarkContains10Safe(b *testing.B) {
148	benchContains(b, 10, NewSet())
149}
150
151func BenchmarkContains10Unsafe(b *testing.B) {
152	benchContains(b, 10, NewThreadUnsafeSet())
153}
154
155func BenchmarkContains100Safe(b *testing.B) {
156	benchContains(b, 100, NewSet())
157}
158
159func BenchmarkContains100Unsafe(b *testing.B) {
160	benchContains(b, 100, NewThreadUnsafeSet())
161}
162
163func benchEqual(b *testing.B, n int, s, t Set) {
164	nums := nrand(n)
165	for _, v := range nums {
166		s.Add(v)
167		t.Add(v)
168	}
169
170	b.ResetTimer()
171	for i := 0; i < b.N; i++ {
172		s.Equal(t)
173	}
174}
175
176func BenchmarkEqual1Safe(b *testing.B) {
177	benchEqual(b, 1, NewSet(), NewSet())
178}
179
180func BenchmarkEqual1Unsafe(b *testing.B) {
181	benchEqual(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet())
182}
183
184func BenchmarkEqual10Safe(b *testing.B) {
185	benchEqual(b, 10, NewSet(), NewSet())
186}
187
188func BenchmarkEqual10Unsafe(b *testing.B) {
189	benchEqual(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet())
190}
191
192func BenchmarkEqual100Safe(b *testing.B) {
193	benchEqual(b, 100, NewSet(), NewSet())
194}
195
196func BenchmarkEqual100Unsafe(b *testing.B) {
197	benchEqual(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet())
198}
199
200func benchDifference(b *testing.B, n int, s, t Set) {
201	nums := nrand(n)
202	for _, v := range nums {
203		s.Add(v)
204	}
205	for _, v := range nums[:n/2] {
206		t.Add(v)
207	}
208
209	b.ResetTimer()
210	for i := 0; i < b.N; i++ {
211		s.Difference(t)
212	}
213}
214
215func benchIsSubset(b *testing.B, n int, s, t Set) {
216	nums := nrand(n)
217	for _, v := range nums {
218		s.Add(v)
219		t.Add(v)
220	}
221
222	b.ResetTimer()
223	for i := 0; i < b.N; i++ {
224		s.IsSubset(t)
225	}
226}
227
228func BenchmarkIsSubset1Safe(b *testing.B) {
229	benchIsSubset(b, 1, NewSet(), NewSet())
230}
231
232func BenchmarkIsSubset1Unsafe(b *testing.B) {
233	benchIsSubset(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet())
234}
235
236func BenchmarkIsSubset10Safe(b *testing.B) {
237	benchIsSubset(b, 10, NewSet(), NewSet())
238}
239
240func BenchmarkIsSubset10Unsafe(b *testing.B) {
241	benchIsSubset(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet())
242}
243
244func BenchmarkIsSubset100Safe(b *testing.B) {
245	benchIsSubset(b, 100, NewSet(), NewSet())
246}
247
248func BenchmarkIsSubset100Unsafe(b *testing.B) {
249	benchIsSubset(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet())
250}
251
252func benchIsSuperset(b *testing.B, n int, s, t Set) {
253	nums := nrand(n)
254	for _, v := range nums {
255		s.Add(v)
256		t.Add(v)
257	}
258
259	b.ResetTimer()
260	for i := 0; i < b.N; i++ {
261		s.IsSuperset(t)
262	}
263}
264
265func BenchmarkIsSuperset1Safe(b *testing.B) {
266	benchIsSuperset(b, 1, NewSet(), NewSet())
267}
268
269func BenchmarkIsSuperset1Unsafe(b *testing.B) {
270	benchIsSuperset(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet())
271}
272
273func BenchmarkIsSuperset10Safe(b *testing.B) {
274	benchIsSuperset(b, 10, NewSet(), NewSet())
275}
276
277func BenchmarkIsSuperset10Unsafe(b *testing.B) {
278	benchIsSuperset(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet())
279}
280
281func BenchmarkIsSuperset100Safe(b *testing.B) {
282	benchIsSuperset(b, 100, NewSet(), NewSet())
283}
284
285func BenchmarkIsSuperset100Unsafe(b *testing.B) {
286	benchIsSuperset(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet())
287}
288
289func benchIsProperSubset(b *testing.B, n int, s, t Set) {
290	nums := nrand(n)
291	for _, v := range nums {
292		s.Add(v)
293		t.Add(v)
294	}
295
296	b.ResetTimer()
297	for i := 0; i < b.N; i++ {
298		s.IsProperSubset(t)
299	}
300}
301
302func BenchmarkIsProperSubset1Safe(b *testing.B) {
303	benchIsProperSubset(b, 1, NewSet(), NewSet())
304}
305
306func BenchmarkIsProperSubset1Unsafe(b *testing.B) {
307	benchIsProperSubset(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet())
308}
309
310func BenchmarkIsProperSubset10Safe(b *testing.B) {
311	benchIsProperSubset(b, 10, NewSet(), NewSet())
312}
313
314func BenchmarkIsProperSubset10Unsafe(b *testing.B) {
315	benchIsProperSubset(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet())
316}
317
318func BenchmarkIsProperSubset100Safe(b *testing.B) {
319	benchIsProperSubset(b, 100, NewSet(), NewSet())
320}
321
322func BenchmarkIsProperSubset100Unsafe(b *testing.B) {
323	benchIsProperSubset(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet())
324}
325
326func benchIsProperSuperset(b *testing.B, n int, s, t Set) {
327	nums := nrand(n)
328	for _, v := range nums {
329		s.Add(v)
330		t.Add(v)
331	}
332
333	b.ResetTimer()
334	for i := 0; i < b.N; i++ {
335		s.IsProperSuperset(t)
336	}
337}
338
339func BenchmarkIsProperSuperset1Safe(b *testing.B) {
340	benchIsProperSuperset(b, 1, NewSet(), NewSet())
341}
342
343func BenchmarkIsProperSuperset1Unsafe(b *testing.B) {
344	benchIsProperSuperset(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet())
345}
346
347func BenchmarkIsProperSuperset10Safe(b *testing.B) {
348	benchIsProperSuperset(b, 10, NewSet(), NewSet())
349}
350
351func BenchmarkIsProperSuperset10Unsafe(b *testing.B) {
352	benchIsProperSuperset(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet())
353}
354
355func BenchmarkIsProperSuperset100Safe(b *testing.B) {
356	benchIsProperSuperset(b, 100, NewSet(), NewSet())
357}
358
359func BenchmarkIsProperSuperset100Unsafe(b *testing.B) {
360	benchIsProperSuperset(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet())
361}
362
363func BenchmarkDifference1Safe(b *testing.B) {
364	benchDifference(b, 1, NewSet(), NewSet())
365}
366
367func BenchmarkDifference1Unsafe(b *testing.B) {
368	benchDifference(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet())
369}
370
371func BenchmarkDifference10Safe(b *testing.B) {
372	benchDifference(b, 10, NewSet(), NewSet())
373}
374
375func BenchmarkDifference10Unsafe(b *testing.B) {
376	benchDifference(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet())
377}
378
379func BenchmarkDifference100Safe(b *testing.B) {
380	benchDifference(b, 100, NewSet(), NewSet())
381}
382
383func BenchmarkDifference100Unsafe(b *testing.B) {
384	benchDifference(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet())
385}
386
387func benchIntersect(b *testing.B, n int, s, t Set) {
388	nums := nrand(int(float64(n) * float64(1.5)))
389	for _, v := range nums[:n] {
390		s.Add(v)
391	}
392	for _, v := range nums[n/2:] {
393		t.Add(v)
394	}
395
396	b.ResetTimer()
397	for i := 0; i < b.N; i++ {
398		s.Intersect(t)
399	}
400}
401
402func BenchmarkIntersect1Safe(b *testing.B) {
403	benchIntersect(b, 1, NewSet(), NewSet())
404}
405
406func BenchmarkIntersect1Unsafe(b *testing.B) {
407	benchIntersect(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet())
408}
409
410func BenchmarkIntersect10Safe(b *testing.B) {
411	benchIntersect(b, 10, NewSet(), NewSet())
412}
413
414func BenchmarkIntersect10Unsafe(b *testing.B) {
415	benchIntersect(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet())
416}
417
418func BenchmarkIntersect100Safe(b *testing.B) {
419	benchIntersect(b, 100, NewSet(), NewSet())
420}
421
422func BenchmarkIntersect100Unsafe(b *testing.B) {
423	benchIntersect(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet())
424}
425
426func benchSymmetricDifference(b *testing.B, n int, s, t Set) {
427	nums := nrand(int(float64(n) * float64(1.5)))
428	for _, v := range nums[:n] {
429		s.Add(v)
430	}
431	for _, v := range nums[n/2:] {
432		t.Add(v)
433	}
434
435	b.ResetTimer()
436	for i := 0; i < b.N; i++ {
437		s.SymmetricDifference(t)
438	}
439}
440
441func BenchmarkSymmetricDifference1Safe(b *testing.B) {
442	benchSymmetricDifference(b, 1, NewSet(), NewSet())
443}
444
445func BenchmarkSymmetricDifference1Unsafe(b *testing.B) {
446	benchSymmetricDifference(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet())
447}
448
449func BenchmarkSymmetricDifference10Safe(b *testing.B) {
450	benchSymmetricDifference(b, 10, NewSet(), NewSet())
451}
452
453func BenchmarkSymmetricDifference10Unsafe(b *testing.B) {
454	benchSymmetricDifference(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet())
455}
456
457func BenchmarkSymmetricDifference100Safe(b *testing.B) {
458	benchSymmetricDifference(b, 100, NewSet(), NewSet())
459}
460
461func BenchmarkSymmetricDifference100Unsafe(b *testing.B) {
462	benchSymmetricDifference(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet())
463}
464
465func benchUnion(b *testing.B, n int, s, t Set) {
466	nums := nrand(n)
467	for _, v := range nums[:n/2] {
468		s.Add(v)
469	}
470	for _, v := range nums[n/2:] {
471		t.Add(v)
472	}
473
474	b.ResetTimer()
475	for i := 0; i < b.N; i++ {
476		s.Union(t)
477	}
478}
479
480func BenchmarkUnion1Safe(b *testing.B) {
481	benchUnion(b, 1, NewSet(), NewSet())
482}
483
484func BenchmarkUnion1Unsafe(b *testing.B) {
485	benchUnion(b, 1, NewThreadUnsafeSet(), NewThreadUnsafeSet())
486}
487
488func BenchmarkUnion10Safe(b *testing.B) {
489	benchUnion(b, 10, NewSet(), NewSet())
490}
491
492func BenchmarkUnion10Unsafe(b *testing.B) {
493	benchUnion(b, 10, NewThreadUnsafeSet(), NewThreadUnsafeSet())
494}
495
496func BenchmarkUnion100Safe(b *testing.B) {
497	benchUnion(b, 100, NewSet(), NewSet())
498}
499
500func BenchmarkUnion100Unsafe(b *testing.B) {
501	benchUnion(b, 100, NewThreadUnsafeSet(), NewThreadUnsafeSet())
502}
503
504func benchEach(b *testing.B, n int, s Set) {
505	nums := nrand(n)
506	for _, v := range nums {
507		s.Add(v)
508	}
509
510	b.ResetTimer()
511	for i := 0; i < b.N; i++ {
512		s.Each(func(elem interface{}) bool {
513			return false
514		})
515	}
516}
517
518func BenchmarkEach1Safe(b *testing.B) {
519	benchEach(b, 1, NewSet())
520}
521
522func BenchmarkEach1Unsafe(b *testing.B) {
523	benchEach(b, 1, NewThreadUnsafeSet())
524}
525
526func BenchmarkEach10Safe(b *testing.B) {
527	benchEach(b, 10, NewSet())
528}
529
530func BenchmarkEach10Unsafe(b *testing.B) {
531	benchEach(b, 10, NewThreadUnsafeSet())
532}
533
534func BenchmarkEach100Safe(b *testing.B) {
535	benchEach(b, 100, NewSet())
536}
537
538func BenchmarkEach100Unsafe(b *testing.B) {
539	benchEach(b, 100, NewThreadUnsafeSet())
540}
541
542func benchIter(b *testing.B, n int, s Set) {
543	nums := nrand(n)
544	for _, v := range nums {
545		s.Add(v)
546	}
547
548	b.ResetTimer()
549	for i := 0; i < b.N; i++ {
550		c := s.Iter()
551		for range c {
552
553		}
554	}
555}
556
557func BenchmarkIter1Safe(b *testing.B) {
558	benchIter(b, 1, NewSet())
559}
560
561func BenchmarkIter1Unsafe(b *testing.B) {
562	benchIter(b, 1, NewThreadUnsafeSet())
563}
564
565func BenchmarkIter10Safe(b *testing.B) {
566	benchIter(b, 10, NewSet())
567}
568
569func BenchmarkIter10Unsafe(b *testing.B) {
570	benchIter(b, 10, NewThreadUnsafeSet())
571}
572
573func BenchmarkIter100Safe(b *testing.B) {
574	benchIter(b, 100, NewSet())
575}
576
577func BenchmarkIter100Unsafe(b *testing.B) {
578	benchIter(b, 100, NewThreadUnsafeSet())
579}
580
581func benchIterator(b *testing.B, n int, s Set) {
582	nums := nrand(n)
583	for _, v := range nums {
584		s.Add(v)
585	}
586
587	b.ResetTimer()
588	for i := 0; i < b.N; i++ {
589		c := s.Iterator().C
590		for range c {
591
592		}
593	}
594}
595
596func BenchmarkIterator1Safe(b *testing.B) {
597	benchIterator(b, 1, NewSet())
598}
599
600func BenchmarkIterator1Unsafe(b *testing.B) {
601	benchIterator(b, 1, NewThreadUnsafeSet())
602}
603
604func BenchmarkIterator10Safe(b *testing.B) {
605	benchIterator(b, 10, NewSet())
606}
607
608func BenchmarkIterator10Unsafe(b *testing.B) {
609	benchIterator(b, 10, NewThreadUnsafeSet())
610}
611
612func BenchmarkIterator100Safe(b *testing.B) {
613	benchIterator(b, 100, NewSet())
614}
615
616func BenchmarkIterator100Unsafe(b *testing.B) {
617	benchIterator(b, 100, NewThreadUnsafeSet())
618}
619
620func benchString(b *testing.B, n int, s Set) {
621	nums := nrand(n)
622	for _, v := range nums {
623		s.Add(v)
624	}
625
626	b.ResetTimer()
627	for i := 0; i < b.N; i++ {
628		_ = s.String()
629	}
630}
631
632func BenchmarkString1Safe(b *testing.B) {
633	benchString(b, 1, NewSet())
634}
635
636func BenchmarkString1Unsafe(b *testing.B) {
637	benchString(b, 1, NewThreadUnsafeSet())
638}
639
640func BenchmarkString10Safe(b *testing.B) {
641	benchString(b, 10, NewSet())
642}
643
644func BenchmarkString10Unsafe(b *testing.B) {
645	benchString(b, 10, NewThreadUnsafeSet())
646}
647
648func BenchmarkString100Safe(b *testing.B) {
649	benchString(b, 100, NewSet())
650}
651
652func BenchmarkString100Unsafe(b *testing.B) {
653	benchString(b, 100, NewThreadUnsafeSet())
654}
655
656func benchToSlice(b *testing.B, s Set) {
657	nums := nrand(b.N)
658	for _, v := range nums {
659		s.Add(v)
660	}
661
662	b.ResetTimer()
663	for i := 0; i < b.N; i++ {
664		s.ToSlice()
665	}
666}
667
668func BenchmarkToSliceSafe(b *testing.B) {
669	benchToSlice(b, NewSet())
670}
671
672func BenchmarkToSliceUnsafe(b *testing.B) {
673	benchToSlice(b, NewThreadUnsafeSet())
674}
675