1package funk
2
3import (
4	"testing"
5
6	"github.com/stretchr/testify/assert"
7)
8
9func TestContainsBool(t *testing.T) {
10	is := assert.New(t)
11
12	is.True(ContainsBool([]bool{true, false}, true))
13	is.False(ContainsBool([]bool{true}, false))
14}
15
16func TestContainsInt(t *testing.T) {
17	is := assert.New(t)
18
19	is.True(ContainsInt([]int{1, 2, 3, 4}, 4))
20	is.False(ContainsInt([]int{1, 2, 3, 4}, 5))
21
22	is.True(ContainsInt32([]int32{1, 2, 3, 4}, 4))
23	is.False(ContainsInt32([]int32{1, 2, 3, 4}, 5))
24
25	is.True(ContainsInt64([]int64{1, 2, 3, 4}, 4))
26	is.False(ContainsInt64([]int64{1, 2, 3, 4}, 5))
27
28	is.True(ContainsUInt([]uint{1, 2, 3, 4}, 4))
29	is.False(ContainsUInt([]uint{1, 2, 3, 4}, 5))
30
31	is.True(ContainsUInt32([]uint32{1, 2, 3, 4}, 4))
32	is.False(ContainsUInt32([]uint32{1, 2, 3, 4}, 5))
33
34	is.True(ContainsUInt64([]uint64{1, 2, 3, 4}, 4))
35	is.False(ContainsUInt64([]uint64{1, 2, 3, 4}, 5))
36}
37
38func TestContainsString(t *testing.T) {
39	is := assert.New(t)
40
41	is.True(ContainsString([]string{"flo", "gilles"}, "flo"))
42	is.False(ContainsString([]string{"flo", "gilles"}, "alex"))
43}
44
45func TestFilterBool(t *testing.T) {
46	is := assert.New(t)
47
48	r := FilterBool([]bool{true, true, false, true}, func(x bool) bool {
49		return x == true
50	})
51
52	is.Equal(r, []bool{true, true, true})
53}
54
55func TestFilterString(t *testing.T) {
56	is := assert.New(t)
57
58	r := FilterString([]string{"a", "b", "c", "d"}, func(x string) bool {
59		return x >= "c"
60	})
61
62	is.Equal(r, []string{"c", "d"})
63}
64
65func TestFilterInt(t *testing.T) {
66	is := assert.New(t)
67
68	r := FilterInt([]int{1, 2, 3, 4}, func(x int) bool {
69		return x%2 == 0
70	})
71
72	is.Equal(r, []int{2, 4})
73}
74
75func TestFilterInt32(t *testing.T) {
76	is := assert.New(t)
77
78	r := FilterInt32([]int32{1, 2, 3, 4}, func(x int32) bool {
79		return x%2 == 0
80	})
81
82	is.Equal(r, []int32{2, 4})
83}
84
85func TestFilterInt64(t *testing.T) {
86	is := assert.New(t)
87
88	r := FilterInt64([]int64{1, 2, 3, 4}, func(x int64) bool {
89		return x%2 == 0
90	})
91
92	is.Equal(r, []int64{2, 4})
93}
94
95func TestFilterUInt(t *testing.T) {
96	is := assert.New(t)
97
98	r := FilterUInt([]uint{1, 2, 3, 4}, func(x uint) bool {
99		return x%2 == 0
100	})
101
102	is.Equal(r, []uint{2, 4})
103}
104
105func TestFilterUInt32(t *testing.T) {
106	is := assert.New(t)
107
108	r := FilterUInt32([]uint32{1, 2, 3, 4}, func(x uint32) bool {
109		return x%2 == 0
110	})
111
112	is.Equal(r, []uint32{2, 4})
113}
114
115func TestFilterUInt64(t *testing.T) {
116	is := assert.New(t)
117
118	r := FilterUInt64([]uint64{1, 2, 3, 4}, func(x uint64) bool {
119		return x%2 == 0
120	})
121
122	is.Equal(r, []uint64{2, 4})
123}
124
125func TestFilterFloat64(t *testing.T) {
126	is := assert.New(t)
127
128	r := FilterFloat64([]float64{1.0, 2.0, 3.0, 4.0}, func(x float64) bool {
129		return int(x)%2 == 0
130	})
131
132	is.Equal(r, []float64{2.0, 4.0})
133}
134
135func TestFilterFloat32(t *testing.T) {
136	is := assert.New(t)
137
138	r := FilterFloat32([]float32{1.0, 2.0, 3.0, 4.0}, func(x float32) bool {
139		return int(x)%2 == 0
140	})
141
142	is.Equal(r, []float32{2.0, 4.0})
143}
144
145func TestContainsFloat(t *testing.T) {
146	is := assert.New(t)
147
148	is.True(ContainsFloat64([]float64{0.1, 0.2}, 0.1))
149	is.False(ContainsFloat64([]float64{0.1, 0.2}, 0.3))
150
151	is.True(ContainsFloat32([]float32{0.1, 0.2}, 0.1))
152	is.False(ContainsFloat32([]float32{0.1, 0.2}, 0.3))
153}
154
155func TestSumNumeral(t *testing.T) {
156	is := assert.New(t)
157
158	is.Equal(SumInt([]int{1, 2, 3}), 6)
159	is.Equal(SumInt64([]int64{1, 2, 3}), int64(6))
160
161	is.Equal(SumUInt([]uint{1, 2, 3}), uint(6))
162	is.Equal(SumUInt64([]uint64{1, 2, 3}), uint64(6))
163
164	is.Equal(SumFloat32([]float32{0.1, 0.2, 0.1}), float32(0.4))
165	is.Equal(SumFloat64([]float64{0.1, 0.2, 0.1}), float64(0.4))
166}
167
168func TestTypesafeReverse(t *testing.T) {
169	is := assert.New(t)
170
171	is.Equal(ReverseBools([]bool{true, false, false}), []bool{false, false, true})
172	is.Equal(ReverseString("abcdefg"), "gfedcba")
173	is.Equal(ReverseInt([]int{1, 2, 3, 4}), []int{4, 3, 2, 1})
174	is.Equal(ReverseInt64([]int64{1, 2, 3, 4}), []int64{4, 3, 2, 1})
175	is.Equal(ReverseUInt([]uint{1, 2, 3, 4}), []uint{4, 3, 2, 1})
176	is.Equal(ReverseUInt64([]uint64{1, 2, 3, 4}), []uint64{4, 3, 2, 1})
177	is.Equal(ReverseStrings([]string{"flo", "gilles"}), []string{"gilles", "flo"})
178	is.Equal(ReverseFloat64([]float64{0.1, 0.2, 0.3}), []float64{0.3, 0.2, 0.1})
179	is.Equal(ReverseFloat32([]float32{0.1, 0.2, 0.3}), []float32{0.3, 0.2, 0.1})
180}
181
182func TestTypesafeIndexOf(t *testing.T) {
183	is := assert.New(t)
184
185	is.Equal(IndexOfBool([]bool{true, false}, false), 1)
186	is.Equal(IndexOfBool([]bool{true}, false), -1)
187
188	is.Equal(IndexOfString([]string{"foo", "bar"}, "bar"), 1)
189	is.Equal(IndexOfString([]string{"foo", "bar"}, "flo"), -1)
190
191	is.Equal(IndexOfInt([]int{0, 1, 2}, 1), 1)
192	is.Equal(IndexOfInt([]int{0, 1, 2}, 3), -1)
193
194	is.Equal(IndexOfInt64([]int64{0, 1, 2}, 1), 1)
195	is.Equal(IndexOfInt64([]int64{0, 1, 2}, 3), -1)
196
197	is.Equal(IndexOfUInt64([]uint64{0, 1, 2}, 1), 1)
198	is.Equal(IndexOfUInt64([]uint64{0, 1, 2}, 3), -1)
199
200	is.Equal(IndexOfFloat64([]float64{0.1, 0.2, 0.3}, 0.2), 1)
201	is.Equal(IndexOfFloat64([]float64{0.1, 0.2, 0.3}, 0.4), -1)
202}
203
204func TestTypesafeLastIndexOf(t *testing.T) {
205	is := assert.New(t)
206
207	is.Equal(LastIndexOfBool([]bool{true, true, false, true}, true), 3)
208	is.Equal(LastIndexOfString([]string{"foo", "bar", "bar"}, "bar"), 2)
209	is.Equal(LastIndexOfInt([]int{1, 2, 2, 3}, 2), 2)
210	is.Equal(LastIndexOfInt64([]int64{1, 2, 2, 3}, 4), -1)
211	is.Equal(LastIndexOfUInt([]uint{1, 2, 2, 3}, 2), 2)
212	is.Equal(LastIndexOfUInt64([]uint64{1, 2, 2, 3}, 4), -1)
213}
214
215func TestTypesafeUniq(t *testing.T) {
216	is := assert.New(t)
217
218	is.Equal(UniqBool([]bool{true, false, false, true, false}), []bool{true, false})
219	is.Equal(UniqInt64([]int64{0, 1, 1, 2, 3, 0, 0, 12}), []int64{0, 1, 2, 3, 12})
220	is.Equal(UniqInt([]int{0, 1, 1, 2, 3, 0, 0, 12}), []int{0, 1, 2, 3, 12})
221	is.Equal(UniqUInt([]uint{0, 1, 1, 2, 3, 0, 0, 12}), []uint{0, 1, 2, 3, 12})
222	is.Equal(UniqUInt64([]uint64{0, 1, 1, 2, 3, 0, 0, 12}), []uint64{0, 1, 2, 3, 12})
223	is.Equal(UniqFloat64([]float64{0.0, 0.1, 0.1, 0.2, 0.3, 0.0, 0.0, 0.12}), []float64{0.0, 0.1, 0.2, 0.3, 0.12})
224	is.Equal(UniqString([]string{"foo", "bar", "foo", "bar"}), []string{"foo", "bar"})
225}
226
227func TestTypesafeShuffle(t *testing.T) {
228	is := assert.New(t)
229
230	initial := []int{1, 2, 3, 5}
231
232	results := ShuffleInt(initial)
233
234	is.Len(results, 4)
235
236	for _, entry := range initial {
237		is.True(ContainsInt(results, entry))
238	}
239}
240
241func TestDropBool(t *testing.T) {
242	results := DropBool([]bool{true, false, false, true, true}, 3)
243
244	is := assert.New(t)
245
246	is.Len(results, 2)
247
248	is.Equal([]bool{true, true}, results)
249}
250
251func TestDropString(t *testing.T) {
252	results := DropString([]string{"the", "quick", "brown", "fox", "jumps", "..."}, 3)
253
254	is := assert.New(t)
255
256	is.Len(results, 3)
257
258	is.Equal([]string{"fox", "jumps", "..."}, results)
259}
260
261func TestDropInt(t *testing.T) {
262	results := DropInt([]int{0, 0, 0, 0}, 3)
263
264	is := assert.New(t)
265
266	is.Len(results, 1)
267
268	is.Equal([]int{0}, results)
269}
270
271func TestDropInt32(t *testing.T) {
272	results := DropInt32([]int32{1, 2, 3, 4}, 3)
273
274	is := assert.New(t)
275
276	is.Len(results, 1)
277
278	is.Equal([]int32{4}, results)
279}
280
281func TestDropInt64(t *testing.T) {
282	results := DropInt64([]int64{1, 2, 3, 4}, 3)
283
284	is := assert.New(t)
285
286	is.Len(results, 1)
287
288	is.Equal([]int64{4}, results)
289}
290
291func TestDropUInt(t *testing.T) {
292	results := DropUInt([]uint{0, 0, 0, 0}, 3)
293
294	is := assert.New(t)
295
296	is.Len(results, 1)
297
298	is.Equal([]uint{0}, results)
299}
300
301func TestDropUInt32(t *testing.T) {
302	results := DropUInt32([]uint32{1, 2, 3, 4}, 3)
303
304	is := assert.New(t)
305
306	is.Len(results, 1)
307
308	is.Equal([]uint32{4}, results)
309}
310
311func TestDropUInt64(t *testing.T) {
312	results := DropUInt64([]uint64{1, 2, 3, 4}, 3)
313
314	is := assert.New(t)
315
316	is.Len(results, 1)
317
318	is.Equal([]uint64{4}, results)
319}
320
321func TestDropFloat32(t *testing.T) {
322	results := DropFloat32([]float32{1.1, 2.2, 3.3, 4.4}, 3)
323
324	is := assert.New(t)
325
326	is.Len(results, 1)
327
328	is.Equal([]float32{4.4}, results)
329}
330
331func TestDropFloat64(t *testing.T) {
332	results := DropFloat64([]float64{1.1, 2.2, 3.3, 4.4}, 3)
333
334	is := assert.New(t)
335
336	is.Len(results, 1)
337
338	is.Equal([]float64{4.4}, results)
339}
340
341func TestChunkStrings(t *testing.T) {
342	is := assert.New(t)
343
344	results := ChunkStrings([]string{"foo", "bar", "foo", "bar", "bar"}, 2)
345
346	is.Len(results, 3)
347	is.Len(results[0], 2)
348	is.Len(results[1], 2)
349	is.Len(results[2], 1)
350	is.Equal([]string{"foo", "bar"}, results[0])
351	is.Equal([]string{"foo", "bar"}, results[1])
352	is.Equal([]string{"bar"}, results[2])
353}
354