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