1 package funk
2
3 import (
4 "testing"
5
6 "github.com/stretchr/testify/assert"
7 )
8
9 func 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
16 func 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
38 func 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
45 func 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
55 func 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
65 func 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
75 func 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
85 func 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
95 func 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
105 func 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
115 func 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
125 func 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
135 func 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
145 func 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
155 func 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
168 func 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
182 func 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
204 func 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
215 func 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
227 func 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
241 func 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
251 func 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
261 func 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
271 func 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
281 func 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
291 func 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
301 func 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
311 func 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
321 func 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
331 func 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
View as plain text