1package objx 2 3import ( 4 "fmt" 5 "testing" 6 7 "github.com/stretchr/testify/assert" 8) 9 10/* 11 Tests for Inter (interface{} and []interface{}) 12*/ 13 14func TestInter(t *testing.T) { 15 val := interface{}("something") 16 17 m := map[string]interface{}{"value": val, "nothing": nil} 18 assert.Equal(t, val, New(m).Get("value").Inter()) 19 assert.Equal(t, val, New(m).Get("value").MustInter()) 20 assert.Equal(t, interface{}(nil), New(m).Get("nothing").Inter()) 21 assert.Equal(t, val, New(m).Get("nothing").Inter("something")) 22 assert.Panics(t, func() { 23 New(m).Get("age").MustInter() 24 }) 25} 26 27func TestInterSlice(t *testing.T) { 28 val := interface{}("something") 29 30 m := map[string]interface{}{"value": []interface{}{val}, "nothing": nil} 31 assert.Equal(t, val, New(m).Get("value").InterSlice()[0]) 32 assert.Equal(t, val, New(m).Get("value").MustInterSlice()[0]) 33 assert.Equal(t, []interface{}(nil), New(m).Get("nothing").InterSlice()) 34 assert.Equal(t, val, New(m).Get("nothing").InterSlice([]interface{}{interface{}("something")})[0]) 35 assert.Panics(t, func() { 36 New(m).Get("nothing").MustInterSlice() 37 }) 38} 39 40func TestIsInter(t *testing.T) { 41 v := &Value{data: interface{}("something")} 42 assert.True(t, v.IsInter()) 43 44} 45 46func TestIsInterSlice(t *testing.T) { 47 v := &Value{data: []interface{}{interface{}("something")}} 48 assert.True(t, v.IsInterSlice()) 49} 50 51func TestEachInter(t *testing.T) { 52 v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} 53 count := 0 54 replacedVals := make([]interface{}, 0) 55 assert.Equal(t, v, v.EachInter(func(i int, val interface{}) bool { 56 count++ 57 replacedVals = append(replacedVals, val) 58 59 // abort early 60 return i != 2 61 })) 62 63 assert.Equal(t, count, 3) 64 assert.Equal(t, replacedVals[0], v.MustInterSlice()[0]) 65 assert.Equal(t, replacedVals[1], v.MustInterSlice()[1]) 66 assert.Equal(t, replacedVals[2], v.MustInterSlice()[2]) 67} 68 69func TestWhereInter(t *testing.T) { 70 v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} 71 72 selected := v.WhereInter(func(i int, val interface{}) bool { 73 return i%2 == 0 74 }).MustInterSlice() 75 76 assert.Equal(t, 3, len(selected)) 77} 78 79func TestGroupInter(t *testing.T) { 80 v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} 81 82 grouped := v.GroupInter(func(i int, val interface{}) string { 83 return fmt.Sprintf("%v", i%2 == 0) 84 }).data.(map[string][]interface{}) 85 86 assert.Equal(t, 2, len(grouped)) 87 assert.Equal(t, 3, len(grouped["true"])) 88 assert.Equal(t, 3, len(grouped["false"])) 89} 90 91func TestReplaceInter(t *testing.T) { 92 v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} 93 94 rawArr := v.MustInterSlice() 95 96 replaced := v.ReplaceInter(func(index int, val interface{}) interface{} { 97 if index < len(rawArr)-1 { 98 return rawArr[index+1] 99 } 100 return rawArr[0] 101 }) 102 103 replacedArr := replaced.MustInterSlice() 104 if assert.Equal(t, 6, len(replacedArr)) { 105 assert.Equal(t, replacedArr[0], rawArr[1]) 106 assert.Equal(t, replacedArr[1], rawArr[2]) 107 assert.Equal(t, replacedArr[2], rawArr[3]) 108 assert.Equal(t, replacedArr[3], rawArr[4]) 109 assert.Equal(t, replacedArr[4], rawArr[5]) 110 assert.Equal(t, replacedArr[5], rawArr[0]) 111 } 112} 113 114func TestCollectInter(t *testing.T) { 115 v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} 116 117 collected := v.CollectInter(func(index int, val interface{}) interface{} { 118 return index 119 }) 120 121 collectedArr := collected.MustInterSlice() 122 if assert.Equal(t, 6, len(collectedArr)) { 123 assert.Equal(t, collectedArr[0], 0) 124 assert.Equal(t, collectedArr[1], 1) 125 assert.Equal(t, collectedArr[2], 2) 126 assert.Equal(t, collectedArr[3], 3) 127 assert.Equal(t, collectedArr[4], 4) 128 assert.Equal(t, collectedArr[5], 5) 129 } 130} 131 132/* 133 Tests for MSI (map[string]interface{} and []map[string]interface{}) 134*/ 135 136func TestMSI(t *testing.T) { 137 val := map[string]interface{}(map[string]interface{}{"name": "Tyler"}) 138 139 m := map[string]interface{}{"value": val, "nothing": nil} 140 assert.Equal(t, val, New(m).Get("value").MSI()) 141 assert.Equal(t, val, New(m).Get("value").MustMSI()) 142 assert.Equal(t, map[string]interface{}(nil), New(m).Get("nothing").MSI()) 143 assert.Equal(t, val, New(m).Get("nothing").MSI(map[string]interface{}{"name": "Tyler"})) 144 assert.Panics(t, func() { 145 New(m).Get("age").MustMSI() 146 }) 147} 148 149func TestMSISlice(t *testing.T) { 150 val := map[string]interface{}(map[string]interface{}{"name": "Tyler"}) 151 152 m := map[string]interface{}{"value": []map[string]interface{}{val}, "nothing": nil} 153 assert.Equal(t, val, New(m).Get("value").MSISlice()[0]) 154 assert.Equal(t, val, New(m).Get("value").MustMSISlice()[0]) 155 assert.Equal(t, []map[string]interface{}(nil), New(m).Get("nothing").MSISlice()) 156 assert.Equal(t, val, New(m).Get("nothing").MSISlice([]map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"})})[0]) 157 assert.Panics(t, func() { 158 New(m).Get("nothing").MustMSISlice() 159 }) 160} 161 162func TestIsMSI(t *testing.T) { 163 v := &Value{data: map[string]interface{}(map[string]interface{}{"name": "Tyler"})} 164 assert.True(t, v.IsMSI()) 165 166} 167 168func TestIsMSISlice(t *testing.T) { 169 v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} 170 assert.True(t, v.IsMSISlice()) 171} 172 173func TestEachMSI(t *testing.T) { 174 v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} 175 count := 0 176 replacedVals := make([]map[string]interface{}, 0) 177 assert.Equal(t, v, v.EachMSI(func(i int, val map[string]interface{}) bool { 178 count++ 179 replacedVals = append(replacedVals, val) 180 181 // abort early 182 return i != 2 183 })) 184 185 assert.Equal(t, count, 3) 186 assert.Equal(t, replacedVals[0], v.MustMSISlice()[0]) 187 assert.Equal(t, replacedVals[1], v.MustMSISlice()[1]) 188 assert.Equal(t, replacedVals[2], v.MustMSISlice()[2]) 189} 190 191func TestWhereMSI(t *testing.T) { 192 v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} 193 194 selected := v.WhereMSI(func(i int, val map[string]interface{}) bool { 195 return i%2 == 0 196 }).MustMSISlice() 197 198 assert.Equal(t, 3, len(selected)) 199} 200 201func TestGroupMSI(t *testing.T) { 202 v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} 203 204 grouped := v.GroupMSI(func(i int, val map[string]interface{}) string { 205 return fmt.Sprintf("%v", i%2 == 0) 206 }).data.(map[string][]map[string]interface{}) 207 208 assert.Equal(t, 2, len(grouped)) 209 assert.Equal(t, 3, len(grouped["true"])) 210 assert.Equal(t, 3, len(grouped["false"])) 211} 212 213func TestReplaceMSI(t *testing.T) { 214 v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} 215 216 rawArr := v.MustMSISlice() 217 218 replaced := v.ReplaceMSI(func(index int, val map[string]interface{}) map[string]interface{} { 219 if index < len(rawArr)-1 { 220 return rawArr[index+1] 221 } 222 return rawArr[0] 223 }) 224 225 replacedArr := replaced.MustMSISlice() 226 if assert.Equal(t, 6, len(replacedArr)) { 227 assert.Equal(t, replacedArr[0], rawArr[1]) 228 assert.Equal(t, replacedArr[1], rawArr[2]) 229 assert.Equal(t, replacedArr[2], rawArr[3]) 230 assert.Equal(t, replacedArr[3], rawArr[4]) 231 assert.Equal(t, replacedArr[4], rawArr[5]) 232 assert.Equal(t, replacedArr[5], rawArr[0]) 233 } 234} 235 236func TestCollectMSI(t *testing.T) { 237 v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} 238 239 collected := v.CollectMSI(func(index int, val map[string]interface{}) interface{} { 240 return index 241 }) 242 243 collectedArr := collected.MustInterSlice() 244 if assert.Equal(t, 6, len(collectedArr)) { 245 assert.Equal(t, collectedArr[0], 0) 246 assert.Equal(t, collectedArr[1], 1) 247 assert.Equal(t, collectedArr[2], 2) 248 assert.Equal(t, collectedArr[3], 3) 249 assert.Equal(t, collectedArr[4], 4) 250 assert.Equal(t, collectedArr[5], 5) 251 } 252} 253 254/* 255 Tests for ObjxMap ((Map) and [](Map)) 256*/ 257 258func TestObjxMap(t *testing.T) { 259 val := (Map)(New(1)) 260 261 m := map[string]interface{}{"value": val, "nothing": nil} 262 assert.Equal(t, val, New(m).Get("value").ObjxMap()) 263 assert.Equal(t, val, New(m).Get("value").MustObjxMap()) 264 assert.Equal(t, (Map)(New(nil)), New(m).Get("nothing").ObjxMap()) 265 assert.Equal(t, val, New(m).Get("nothing").ObjxMap(New(1))) 266 assert.Panics(t, func() { 267 New(m).Get("age").MustObjxMap() 268 }) 269} 270 271func TestObjxMapSlice(t *testing.T) { 272 val := (Map)(New(1)) 273 274 m := map[string]interface{}{"value": [](Map){val}, "nothing": nil} 275 assert.Equal(t, val, New(m).Get("value").ObjxMapSlice()[0]) 276 assert.Equal(t, val, New(m).Get("value").MustObjxMapSlice()[0]) 277 assert.Equal(t, [](Map)(nil), New(m).Get("nothing").ObjxMapSlice()) 278 assert.Equal(t, val, New(m).Get("nothing").ObjxMapSlice([](Map){(Map)(New(1))})[0]) 279 assert.Panics(t, func() { 280 New(m).Get("nothing").MustObjxMapSlice() 281 }) 282} 283 284func TestIsObjxMap(t *testing.T) { 285 v := &Value{data: (Map)(New(1))} 286 assert.True(t, v.IsObjxMap()) 287 288} 289 290func TestIsObjxMapSlice(t *testing.T) { 291 v := &Value{data: [](Map){(Map)(New(1))}} 292 assert.True(t, v.IsObjxMapSlice()) 293} 294 295func TestEachObjxMap(t *testing.T) { 296 v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}} 297 count := 0 298 replacedVals := make([](Map), 0) 299 assert.Equal(t, v, v.EachObjxMap(func(i int, val Map) bool { 300 count++ 301 replacedVals = append(replacedVals, val) 302 303 // abort early 304 return i != 2 305 })) 306 307 assert.Equal(t, count, 3) 308 assert.Equal(t, replacedVals[0], v.MustObjxMapSlice()[0]) 309 assert.Equal(t, replacedVals[1], v.MustObjxMapSlice()[1]) 310 assert.Equal(t, replacedVals[2], v.MustObjxMapSlice()[2]) 311} 312 313func TestWhereObjxMap(t *testing.T) { 314 v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}} 315 316 selected := v.WhereObjxMap(func(i int, val Map) bool { 317 return i%2 == 0 318 }).MustObjxMapSlice() 319 320 assert.Equal(t, 3, len(selected)) 321} 322 323func TestGroupObjxMap(t *testing.T) { 324 v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}} 325 326 grouped := v.GroupObjxMap(func(i int, val Map) string { 327 return fmt.Sprintf("%v", i%2 == 0) 328 }).data.(map[string][](Map)) 329 330 assert.Equal(t, 2, len(grouped)) 331 assert.Equal(t, 3, len(grouped["true"])) 332 assert.Equal(t, 3, len(grouped["false"])) 333} 334 335func TestReplaceObjxMap(t *testing.T) { 336 v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}} 337 338 rawArr := v.MustObjxMapSlice() 339 340 replaced := v.ReplaceObjxMap(func(index int, val Map) Map { 341 if index < len(rawArr)-1 { 342 return rawArr[index+1] 343 } 344 return rawArr[0] 345 }) 346 347 replacedArr := replaced.MustObjxMapSlice() 348 if assert.Equal(t, 6, len(replacedArr)) { 349 assert.Equal(t, replacedArr[0], rawArr[1]) 350 assert.Equal(t, replacedArr[1], rawArr[2]) 351 assert.Equal(t, replacedArr[2], rawArr[3]) 352 assert.Equal(t, replacedArr[3], rawArr[4]) 353 assert.Equal(t, replacedArr[4], rawArr[5]) 354 assert.Equal(t, replacedArr[5], rawArr[0]) 355 } 356} 357 358func TestCollectObjxMap(t *testing.T) { 359 v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}} 360 361 collected := v.CollectObjxMap(func(index int, val Map) interface{} { 362 return index 363 }) 364 365 collectedArr := collected.MustInterSlice() 366 if assert.Equal(t, 6, len(collectedArr)) { 367 assert.Equal(t, collectedArr[0], 0) 368 assert.Equal(t, collectedArr[1], 1) 369 assert.Equal(t, collectedArr[2], 2) 370 assert.Equal(t, collectedArr[3], 3) 371 assert.Equal(t, collectedArr[4], 4) 372 assert.Equal(t, collectedArr[5], 5) 373 } 374} 375 376/* 377 Tests for Bool (bool and []bool) 378*/ 379 380func TestBool(t *testing.T) { 381 val := bool(true) 382 383 m := map[string]interface{}{"value": val, "nothing": nil} 384 assert.Equal(t, val, New(m).Get("value").Bool()) 385 assert.Equal(t, val, New(m).Get("value").MustBool()) 386 assert.Equal(t, bool(false), New(m).Get("nothing").Bool()) 387 assert.Equal(t, val, New(m).Get("nothing").Bool(true)) 388 assert.Panics(t, func() { 389 New(m).Get("age").MustBool() 390 }) 391} 392 393func TestBoolSlice(t *testing.T) { 394 val := bool(true) 395 396 m := map[string]interface{}{"value": []bool{val}, "nothing": nil} 397 assert.Equal(t, val, New(m).Get("value").BoolSlice()[0]) 398 assert.Equal(t, val, New(m).Get("value").MustBoolSlice()[0]) 399 assert.Equal(t, []bool(nil), New(m).Get("nothing").BoolSlice()) 400 assert.Equal(t, val, New(m).Get("nothing").BoolSlice([]bool{bool(true)})[0]) 401 assert.Panics(t, func() { 402 New(m).Get("nothing").MustBoolSlice() 403 }) 404} 405 406func TestIsBool(t *testing.T) { 407 v := &Value{data: bool(true)} 408 assert.True(t, v.IsBool()) 409 410} 411 412func TestIsBoolSlice(t *testing.T) { 413 v := &Value{data: []bool{bool(true)}} 414 assert.True(t, v.IsBoolSlice()) 415} 416 417func TestEachBool(t *testing.T) { 418 v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true)}} 419 count := 0 420 replacedVals := make([]bool, 0) 421 assert.Equal(t, v, v.EachBool(func(i int, val bool) bool { 422 count++ 423 replacedVals = append(replacedVals, val) 424 425 // abort early 426 return i != 2 427 })) 428 429 assert.Equal(t, count, 3) 430 assert.Equal(t, replacedVals[0], v.MustBoolSlice()[0]) 431 assert.Equal(t, replacedVals[1], v.MustBoolSlice()[1]) 432 assert.Equal(t, replacedVals[2], v.MustBoolSlice()[2]) 433} 434 435func TestWhereBool(t *testing.T) { 436 v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} 437 438 selected := v.WhereBool(func(i int, val bool) bool { 439 return i%2 == 0 440 }).MustBoolSlice() 441 442 assert.Equal(t, 3, len(selected)) 443} 444 445func TestGroupBool(t *testing.T) { 446 v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} 447 448 grouped := v.GroupBool(func(i int, val bool) string { 449 return fmt.Sprintf("%v", i%2 == 0) 450 }).data.(map[string][]bool) 451 452 assert.Equal(t, 2, len(grouped)) 453 assert.Equal(t, 3, len(grouped["true"])) 454 assert.Equal(t, 3, len(grouped["false"])) 455} 456 457func TestReplaceBool(t *testing.T) { 458 v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} 459 460 rawArr := v.MustBoolSlice() 461 462 replaced := v.ReplaceBool(func(index int, val bool) bool { 463 if index < len(rawArr)-1 { 464 return rawArr[index+1] 465 } 466 return rawArr[0] 467 }) 468 469 replacedArr := replaced.MustBoolSlice() 470 if assert.Equal(t, 6, len(replacedArr)) { 471 assert.Equal(t, replacedArr[0], rawArr[1]) 472 assert.Equal(t, replacedArr[1], rawArr[2]) 473 assert.Equal(t, replacedArr[2], rawArr[3]) 474 assert.Equal(t, replacedArr[3], rawArr[4]) 475 assert.Equal(t, replacedArr[4], rawArr[5]) 476 assert.Equal(t, replacedArr[5], rawArr[0]) 477 } 478} 479 480func TestCollectBool(t *testing.T) { 481 v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} 482 483 collected := v.CollectBool(func(index int, val bool) interface{} { 484 return index 485 }) 486 487 collectedArr := collected.MustInterSlice() 488 if assert.Equal(t, 6, len(collectedArr)) { 489 assert.Equal(t, collectedArr[0], 0) 490 assert.Equal(t, collectedArr[1], 1) 491 assert.Equal(t, collectedArr[2], 2) 492 assert.Equal(t, collectedArr[3], 3) 493 assert.Equal(t, collectedArr[4], 4) 494 assert.Equal(t, collectedArr[5], 5) 495 } 496} 497 498/* 499 Tests for Str (string and []string) 500*/ 501 502func TestStr(t *testing.T) { 503 val := string("hello") 504 505 m := map[string]interface{}{"value": val, "nothing": nil} 506 assert.Equal(t, val, New(m).Get("value").Str()) 507 assert.Equal(t, val, New(m).Get("value").MustStr()) 508 assert.Equal(t, string(""), New(m).Get("nothing").Str()) 509 assert.Equal(t, val, New(m).Get("nothing").Str("hello")) 510 assert.Panics(t, func() { 511 New(m).Get("age").MustStr() 512 }) 513} 514 515func TestStrSlice(t *testing.T) { 516 val := string("hello") 517 518 m := map[string]interface{}{"value": []string{val}, "nothing": nil} 519 assert.Equal(t, val, New(m).Get("value").StrSlice()[0]) 520 assert.Equal(t, val, New(m).Get("value").MustStrSlice()[0]) 521 assert.Equal(t, []string(nil), New(m).Get("nothing").StrSlice()) 522 assert.Equal(t, val, New(m).Get("nothing").StrSlice([]string{string("hello")})[0]) 523 assert.Panics(t, func() { 524 New(m).Get("nothing").MustStrSlice() 525 }) 526} 527 528func TestIsStr(t *testing.T) { 529 v := &Value{data: string("hello")} 530 assert.True(t, v.IsStr()) 531 532} 533 534func TestIsStrSlice(t *testing.T) { 535 v := &Value{data: []string{string("hello")}} 536 assert.True(t, v.IsStrSlice()) 537} 538 539func TestEachStr(t *testing.T) { 540 v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} 541 count := 0 542 replacedVals := make([]string, 0) 543 assert.Equal(t, v, v.EachStr(func(i int, val string) bool { 544 count++ 545 replacedVals = append(replacedVals, val) 546 547 // abort early 548 return i != 2 549 })) 550 551 assert.Equal(t, count, 3) 552 assert.Equal(t, replacedVals[0], v.MustStrSlice()[0]) 553 assert.Equal(t, replacedVals[1], v.MustStrSlice()[1]) 554 assert.Equal(t, replacedVals[2], v.MustStrSlice()[2]) 555} 556 557func TestWhereStr(t *testing.T) { 558 v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} 559 560 selected := v.WhereStr(func(i int, val string) bool { 561 return i%2 == 0 562 }).MustStrSlice() 563 564 assert.Equal(t, 3, len(selected)) 565} 566 567func TestGroupStr(t *testing.T) { 568 v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} 569 570 grouped := v.GroupStr(func(i int, val string) string { 571 return fmt.Sprintf("%v", i%2 == 0) 572 }).data.(map[string][]string) 573 574 assert.Equal(t, 2, len(grouped)) 575 assert.Equal(t, 3, len(grouped["true"])) 576 assert.Equal(t, 3, len(grouped["false"])) 577} 578 579func TestReplaceStr(t *testing.T) { 580 v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} 581 582 rawArr := v.MustStrSlice() 583 584 replaced := v.ReplaceStr(func(index int, val string) string { 585 if index < len(rawArr)-1 { 586 return rawArr[index+1] 587 } 588 return rawArr[0] 589 }) 590 591 replacedArr := replaced.MustStrSlice() 592 if assert.Equal(t, 6, len(replacedArr)) { 593 assert.Equal(t, replacedArr[0], rawArr[1]) 594 assert.Equal(t, replacedArr[1], rawArr[2]) 595 assert.Equal(t, replacedArr[2], rawArr[3]) 596 assert.Equal(t, replacedArr[3], rawArr[4]) 597 assert.Equal(t, replacedArr[4], rawArr[5]) 598 assert.Equal(t, replacedArr[5], rawArr[0]) 599 } 600} 601 602func TestCollectStr(t *testing.T) { 603 v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} 604 605 collected := v.CollectStr(func(index int, val string) interface{} { 606 return index 607 }) 608 609 collectedArr := collected.MustInterSlice() 610 if assert.Equal(t, 6, len(collectedArr)) { 611 assert.Equal(t, collectedArr[0], 0) 612 assert.Equal(t, collectedArr[1], 1) 613 assert.Equal(t, collectedArr[2], 2) 614 assert.Equal(t, collectedArr[3], 3) 615 assert.Equal(t, collectedArr[4], 4) 616 assert.Equal(t, collectedArr[5], 5) 617 } 618} 619 620/* 621 Tests for Int (int and []int) 622*/ 623 624func TestInt(t *testing.T) { 625 val := int(1) 626 627 m := map[string]interface{}{"value": val, "nothing": nil} 628 assert.Equal(t, val, New(m).Get("value").Int()) 629 assert.Equal(t, val, New(m).Get("value").MustInt()) 630 assert.Equal(t, int(0), New(m).Get("nothing").Int()) 631 assert.Equal(t, val, New(m).Get("nothing").Int(1)) 632 assert.Panics(t, func() { 633 New(m).Get("age").MustInt() 634 }) 635} 636 637func TestIntSlice(t *testing.T) { 638 val := int(1) 639 640 m := map[string]interface{}{"value": []int{val}, "nothing": nil} 641 assert.Equal(t, val, New(m).Get("value").IntSlice()[0]) 642 assert.Equal(t, val, New(m).Get("value").MustIntSlice()[0]) 643 assert.Equal(t, []int(nil), New(m).Get("nothing").IntSlice()) 644 assert.Equal(t, val, New(m).Get("nothing").IntSlice([]int{int(1)})[0]) 645 assert.Panics(t, func() { 646 New(m).Get("nothing").MustIntSlice() 647 }) 648} 649 650func TestIsInt(t *testing.T) { 651 v := &Value{data: int(1)} 652 assert.True(t, v.IsInt()) 653 654} 655 656func TestIsIntSlice(t *testing.T) { 657 v := &Value{data: []int{int(1)}} 658 assert.True(t, v.IsIntSlice()) 659} 660 661func TestEachInt(t *testing.T) { 662 v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1)}} 663 count := 0 664 replacedVals := make([]int, 0) 665 assert.Equal(t, v, v.EachInt(func(i int, val int) bool { 666 count++ 667 replacedVals = append(replacedVals, val) 668 669 // abort early 670 return i != 2 671 })) 672 673 assert.Equal(t, count, 3) 674 assert.Equal(t, replacedVals[0], v.MustIntSlice()[0]) 675 assert.Equal(t, replacedVals[1], v.MustIntSlice()[1]) 676 assert.Equal(t, replacedVals[2], v.MustIntSlice()[2]) 677} 678 679func TestWhereInt(t *testing.T) { 680 v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}} 681 682 selected := v.WhereInt(func(i int, val int) bool { 683 return i%2 == 0 684 }).MustIntSlice() 685 686 assert.Equal(t, 3, len(selected)) 687} 688 689func TestGroupInt(t *testing.T) { 690 v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}} 691 692 grouped := v.GroupInt(func(i int, val int) string { 693 return fmt.Sprintf("%v", i%2 == 0) 694 }).data.(map[string][]int) 695 696 assert.Equal(t, 2, len(grouped)) 697 assert.Equal(t, 3, len(grouped["true"])) 698 assert.Equal(t, 3, len(grouped["false"])) 699} 700 701func TestReplaceInt(t *testing.T) { 702 v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}} 703 704 rawArr := v.MustIntSlice() 705 706 replaced := v.ReplaceInt(func(index int, val int) int { 707 if index < len(rawArr)-1 { 708 return rawArr[index+1] 709 } 710 return rawArr[0] 711 }) 712 713 replacedArr := replaced.MustIntSlice() 714 if assert.Equal(t, 6, len(replacedArr)) { 715 assert.Equal(t, replacedArr[0], rawArr[1]) 716 assert.Equal(t, replacedArr[1], rawArr[2]) 717 assert.Equal(t, replacedArr[2], rawArr[3]) 718 assert.Equal(t, replacedArr[3], rawArr[4]) 719 assert.Equal(t, replacedArr[4], rawArr[5]) 720 assert.Equal(t, replacedArr[5], rawArr[0]) 721 } 722} 723 724func TestCollectInt(t *testing.T) { 725 v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}} 726 727 collected := v.CollectInt(func(index int, val int) interface{} { 728 return index 729 }) 730 731 collectedArr := collected.MustInterSlice() 732 if assert.Equal(t, 6, len(collectedArr)) { 733 assert.Equal(t, collectedArr[0], 0) 734 assert.Equal(t, collectedArr[1], 1) 735 assert.Equal(t, collectedArr[2], 2) 736 assert.Equal(t, collectedArr[3], 3) 737 assert.Equal(t, collectedArr[4], 4) 738 assert.Equal(t, collectedArr[5], 5) 739 } 740} 741 742/* 743 Tests for Int8 (int8 and []int8) 744*/ 745 746func TestInt8(t *testing.T) { 747 val := int8(1) 748 749 m := map[string]interface{}{"value": val, "nothing": nil} 750 assert.Equal(t, val, New(m).Get("value").Int8()) 751 assert.Equal(t, val, New(m).Get("value").MustInt8()) 752 assert.Equal(t, int8(0), New(m).Get("nothing").Int8()) 753 assert.Equal(t, val, New(m).Get("nothing").Int8(1)) 754 assert.Panics(t, func() { 755 New(m).Get("age").MustInt8() 756 }) 757} 758 759func TestInt8Slice(t *testing.T) { 760 val := int8(1) 761 762 m := map[string]interface{}{"value": []int8{val}, "nothing": nil} 763 assert.Equal(t, val, New(m).Get("value").Int8Slice()[0]) 764 assert.Equal(t, val, New(m).Get("value").MustInt8Slice()[0]) 765 assert.Equal(t, []int8(nil), New(m).Get("nothing").Int8Slice()) 766 assert.Equal(t, val, New(m).Get("nothing").Int8Slice([]int8{int8(1)})[0]) 767 assert.Panics(t, func() { 768 New(m).Get("nothing").MustInt8Slice() 769 }) 770} 771 772func TestIsInt8(t *testing.T) { 773 v := &Value{data: int8(1)} 774 assert.True(t, v.IsInt8()) 775 776} 777 778func TestIsInt8Slice(t *testing.T) { 779 v := &Value{data: []int8{int8(1)}} 780 assert.True(t, v.IsInt8Slice()) 781} 782 783func TestEachInt8(t *testing.T) { 784 v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1)}} 785 count := 0 786 replacedVals := make([]int8, 0) 787 assert.Equal(t, v, v.EachInt8(func(i int, val int8) bool { 788 count++ 789 replacedVals = append(replacedVals, val) 790 791 // abort early 792 return i != 2 793 })) 794 795 assert.Equal(t, count, 3) 796 assert.Equal(t, replacedVals[0], v.MustInt8Slice()[0]) 797 assert.Equal(t, replacedVals[1], v.MustInt8Slice()[1]) 798 assert.Equal(t, replacedVals[2], v.MustInt8Slice()[2]) 799} 800 801func TestWhereInt8(t *testing.T) { 802 v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} 803 804 selected := v.WhereInt8(func(i int, val int8) bool { 805 return i%2 == 0 806 }).MustInt8Slice() 807 808 assert.Equal(t, 3, len(selected)) 809} 810 811func TestGroupInt8(t *testing.T) { 812 v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} 813 814 grouped := v.GroupInt8(func(i int, val int8) string { 815 return fmt.Sprintf("%v", i%2 == 0) 816 }).data.(map[string][]int8) 817 818 assert.Equal(t, 2, len(grouped)) 819 assert.Equal(t, 3, len(grouped["true"])) 820 assert.Equal(t, 3, len(grouped["false"])) 821} 822 823func TestReplaceInt8(t *testing.T) { 824 v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} 825 826 rawArr := v.MustInt8Slice() 827 828 replaced := v.ReplaceInt8(func(index int, val int8) int8 { 829 if index < len(rawArr)-1 { 830 return rawArr[index+1] 831 } 832 return rawArr[0] 833 }) 834 835 replacedArr := replaced.MustInt8Slice() 836 if assert.Equal(t, 6, len(replacedArr)) { 837 assert.Equal(t, replacedArr[0], rawArr[1]) 838 assert.Equal(t, replacedArr[1], rawArr[2]) 839 assert.Equal(t, replacedArr[2], rawArr[3]) 840 assert.Equal(t, replacedArr[3], rawArr[4]) 841 assert.Equal(t, replacedArr[4], rawArr[5]) 842 assert.Equal(t, replacedArr[5], rawArr[0]) 843 } 844} 845 846func TestCollectInt8(t *testing.T) { 847 v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} 848 849 collected := v.CollectInt8(func(index int, val int8) interface{} { 850 return index 851 }) 852 853 collectedArr := collected.MustInterSlice() 854 if assert.Equal(t, 6, len(collectedArr)) { 855 assert.Equal(t, collectedArr[0], 0) 856 assert.Equal(t, collectedArr[1], 1) 857 assert.Equal(t, collectedArr[2], 2) 858 assert.Equal(t, collectedArr[3], 3) 859 assert.Equal(t, collectedArr[4], 4) 860 assert.Equal(t, collectedArr[5], 5) 861 } 862} 863 864/* 865 Tests for Int16 (int16 and []int16) 866*/ 867 868func TestInt16(t *testing.T) { 869 val := int16(1) 870 871 m := map[string]interface{}{"value": val, "nothing": nil} 872 assert.Equal(t, val, New(m).Get("value").Int16()) 873 assert.Equal(t, val, New(m).Get("value").MustInt16()) 874 assert.Equal(t, int16(0), New(m).Get("nothing").Int16()) 875 assert.Equal(t, val, New(m).Get("nothing").Int16(1)) 876 assert.Panics(t, func() { 877 New(m).Get("age").MustInt16() 878 }) 879} 880 881func TestInt16Slice(t *testing.T) { 882 val := int16(1) 883 884 m := map[string]interface{}{"value": []int16{val}, "nothing": nil} 885 assert.Equal(t, val, New(m).Get("value").Int16Slice()[0]) 886 assert.Equal(t, val, New(m).Get("value").MustInt16Slice()[0]) 887 assert.Equal(t, []int16(nil), New(m).Get("nothing").Int16Slice()) 888 assert.Equal(t, val, New(m).Get("nothing").Int16Slice([]int16{int16(1)})[0]) 889 assert.Panics(t, func() { 890 New(m).Get("nothing").MustInt16Slice() 891 }) 892} 893 894func TestIsInt16(t *testing.T) { 895 v := &Value{data: int16(1)} 896 assert.True(t, v.IsInt16()) 897 898} 899 900func TestIsInt16Slice(t *testing.T) { 901 v := &Value{data: []int16{int16(1)}} 902 assert.True(t, v.IsInt16Slice()) 903} 904 905func TestEachInt16(t *testing.T) { 906 v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1)}} 907 count := 0 908 replacedVals := make([]int16, 0) 909 assert.Equal(t, v, v.EachInt16(func(i int, val int16) bool { 910 count++ 911 replacedVals = append(replacedVals, val) 912 913 // abort early 914 return i != 2 915 })) 916 917 assert.Equal(t, count, 3) 918 assert.Equal(t, replacedVals[0], v.MustInt16Slice()[0]) 919 assert.Equal(t, replacedVals[1], v.MustInt16Slice()[1]) 920 assert.Equal(t, replacedVals[2], v.MustInt16Slice()[2]) 921} 922 923func TestWhereInt16(t *testing.T) { 924 v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} 925 926 selected := v.WhereInt16(func(i int, val int16) bool { 927 return i%2 == 0 928 }).MustInt16Slice() 929 930 assert.Equal(t, 3, len(selected)) 931} 932 933func TestGroupInt16(t *testing.T) { 934 v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} 935 936 grouped := v.GroupInt16(func(i int, val int16) string { 937 return fmt.Sprintf("%v", i%2 == 0) 938 }).data.(map[string][]int16) 939 940 assert.Equal(t, 2, len(grouped)) 941 assert.Equal(t, 3, len(grouped["true"])) 942 assert.Equal(t, 3, len(grouped["false"])) 943} 944 945func TestReplaceInt16(t *testing.T) { 946 v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} 947 948 rawArr := v.MustInt16Slice() 949 950 replaced := v.ReplaceInt16(func(index int, val int16) int16 { 951 if index < len(rawArr)-1 { 952 return rawArr[index+1] 953 } 954 return rawArr[0] 955 }) 956 957 replacedArr := replaced.MustInt16Slice() 958 if assert.Equal(t, 6, len(replacedArr)) { 959 assert.Equal(t, replacedArr[0], rawArr[1]) 960 assert.Equal(t, replacedArr[1], rawArr[2]) 961 assert.Equal(t, replacedArr[2], rawArr[3]) 962 assert.Equal(t, replacedArr[3], rawArr[4]) 963 assert.Equal(t, replacedArr[4], rawArr[5]) 964 assert.Equal(t, replacedArr[5], rawArr[0]) 965 } 966} 967 968func TestCollectInt16(t *testing.T) { 969 v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} 970 971 collected := v.CollectInt16(func(index int, val int16) interface{} { 972 return index 973 }) 974 975 collectedArr := collected.MustInterSlice() 976 if assert.Equal(t, 6, len(collectedArr)) { 977 assert.Equal(t, collectedArr[0], 0) 978 assert.Equal(t, collectedArr[1], 1) 979 assert.Equal(t, collectedArr[2], 2) 980 assert.Equal(t, collectedArr[3], 3) 981 assert.Equal(t, collectedArr[4], 4) 982 assert.Equal(t, collectedArr[5], 5) 983 } 984} 985 986/* 987 Tests for Int32 (int32 and []int32) 988*/ 989 990func TestInt32(t *testing.T) { 991 val := int32(1) 992 993 m := map[string]interface{}{"value": val, "nothing": nil} 994 assert.Equal(t, val, New(m).Get("value").Int32()) 995 assert.Equal(t, val, New(m).Get("value").MustInt32()) 996 assert.Equal(t, int32(0), New(m).Get("nothing").Int32()) 997 assert.Equal(t, val, New(m).Get("nothing").Int32(1)) 998 assert.Panics(t, func() { 999 New(m).Get("age").MustInt32() 1000 }) 1001} 1002 1003func TestInt32Slice(t *testing.T) { 1004 val := int32(1) 1005 1006 m := map[string]interface{}{"value": []int32{val}, "nothing": nil} 1007 assert.Equal(t, val, New(m).Get("value").Int32Slice()[0]) 1008 assert.Equal(t, val, New(m).Get("value").MustInt32Slice()[0]) 1009 assert.Equal(t, []int32(nil), New(m).Get("nothing").Int32Slice()) 1010 assert.Equal(t, val, New(m).Get("nothing").Int32Slice([]int32{int32(1)})[0]) 1011 assert.Panics(t, func() { 1012 New(m).Get("nothing").MustInt32Slice() 1013 }) 1014} 1015 1016func TestIsInt32(t *testing.T) { 1017 v := &Value{data: int32(1)} 1018 assert.True(t, v.IsInt32()) 1019 1020} 1021 1022func TestIsInt32Slice(t *testing.T) { 1023 v := &Value{data: []int32{int32(1)}} 1024 assert.True(t, v.IsInt32Slice()) 1025} 1026 1027func TestEachInt32(t *testing.T) { 1028 v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1)}} 1029 count := 0 1030 replacedVals := make([]int32, 0) 1031 assert.Equal(t, v, v.EachInt32(func(i int, val int32) bool { 1032 count++ 1033 replacedVals = append(replacedVals, val) 1034 1035 // abort early 1036 return i != 2 1037 })) 1038 1039 assert.Equal(t, count, 3) 1040 assert.Equal(t, replacedVals[0], v.MustInt32Slice()[0]) 1041 assert.Equal(t, replacedVals[1], v.MustInt32Slice()[1]) 1042 assert.Equal(t, replacedVals[2], v.MustInt32Slice()[2]) 1043} 1044 1045func TestWhereInt32(t *testing.T) { 1046 v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} 1047 1048 selected := v.WhereInt32(func(i int, val int32) bool { 1049 return i%2 == 0 1050 }).MustInt32Slice() 1051 1052 assert.Equal(t, 3, len(selected)) 1053} 1054 1055func TestGroupInt32(t *testing.T) { 1056 v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} 1057 1058 grouped := v.GroupInt32(func(i int, val int32) string { 1059 return fmt.Sprintf("%v", i%2 == 0) 1060 }).data.(map[string][]int32) 1061 1062 assert.Equal(t, 2, len(grouped)) 1063 assert.Equal(t, 3, len(grouped["true"])) 1064 assert.Equal(t, 3, len(grouped["false"])) 1065} 1066 1067func TestReplaceInt32(t *testing.T) { 1068 v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} 1069 1070 rawArr := v.MustInt32Slice() 1071 1072 replaced := v.ReplaceInt32(func(index int, val int32) int32 { 1073 if index < len(rawArr)-1 { 1074 return rawArr[index+1] 1075 } 1076 return rawArr[0] 1077 }) 1078 1079 replacedArr := replaced.MustInt32Slice() 1080 if assert.Equal(t, 6, len(replacedArr)) { 1081 assert.Equal(t, replacedArr[0], rawArr[1]) 1082 assert.Equal(t, replacedArr[1], rawArr[2]) 1083 assert.Equal(t, replacedArr[2], rawArr[3]) 1084 assert.Equal(t, replacedArr[3], rawArr[4]) 1085 assert.Equal(t, replacedArr[4], rawArr[5]) 1086 assert.Equal(t, replacedArr[5], rawArr[0]) 1087 } 1088} 1089 1090func TestCollectInt32(t *testing.T) { 1091 v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} 1092 1093 collected := v.CollectInt32(func(index int, val int32) interface{} { 1094 return index 1095 }) 1096 1097 collectedArr := collected.MustInterSlice() 1098 if assert.Equal(t, 6, len(collectedArr)) { 1099 assert.Equal(t, collectedArr[0], 0) 1100 assert.Equal(t, collectedArr[1], 1) 1101 assert.Equal(t, collectedArr[2], 2) 1102 assert.Equal(t, collectedArr[3], 3) 1103 assert.Equal(t, collectedArr[4], 4) 1104 assert.Equal(t, collectedArr[5], 5) 1105 } 1106} 1107 1108/* 1109 Tests for Int64 (int64 and []int64) 1110*/ 1111 1112func TestInt64(t *testing.T) { 1113 val := int64(1) 1114 1115 m := map[string]interface{}{"value": val, "nothing": nil} 1116 assert.Equal(t, val, New(m).Get("value").Int64()) 1117 assert.Equal(t, val, New(m).Get("value").MustInt64()) 1118 assert.Equal(t, int64(0), New(m).Get("nothing").Int64()) 1119 assert.Equal(t, val, New(m).Get("nothing").Int64(1)) 1120 assert.Panics(t, func() { 1121 New(m).Get("age").MustInt64() 1122 }) 1123} 1124 1125func TestInt64Slice(t *testing.T) { 1126 val := int64(1) 1127 1128 m := map[string]interface{}{"value": []int64{val}, "nothing": nil} 1129 assert.Equal(t, val, New(m).Get("value").Int64Slice()[0]) 1130 assert.Equal(t, val, New(m).Get("value").MustInt64Slice()[0]) 1131 assert.Equal(t, []int64(nil), New(m).Get("nothing").Int64Slice()) 1132 assert.Equal(t, val, New(m).Get("nothing").Int64Slice([]int64{int64(1)})[0]) 1133 assert.Panics(t, func() { 1134 New(m).Get("nothing").MustInt64Slice() 1135 }) 1136} 1137 1138func TestIsInt64(t *testing.T) { 1139 v := &Value{data: int64(1)} 1140 assert.True(t, v.IsInt64()) 1141 1142} 1143 1144func TestIsInt64Slice(t *testing.T) { 1145 v := &Value{data: []int64{int64(1)}} 1146 assert.True(t, v.IsInt64Slice()) 1147} 1148 1149func TestEachInt64(t *testing.T) { 1150 v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1)}} 1151 count := 0 1152 replacedVals := make([]int64, 0) 1153 assert.Equal(t, v, v.EachInt64(func(i int, val int64) bool { 1154 count++ 1155 replacedVals = append(replacedVals, val) 1156 1157 // abort early 1158 return i != 2 1159 })) 1160 1161 assert.Equal(t, count, 3) 1162 assert.Equal(t, replacedVals[0], v.MustInt64Slice()[0]) 1163 assert.Equal(t, replacedVals[1], v.MustInt64Slice()[1]) 1164 assert.Equal(t, replacedVals[2], v.MustInt64Slice()[2]) 1165} 1166 1167func TestWhereInt64(t *testing.T) { 1168 v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} 1169 1170 selected := v.WhereInt64(func(i int, val int64) bool { 1171 return i%2 == 0 1172 }).MustInt64Slice() 1173 1174 assert.Equal(t, 3, len(selected)) 1175} 1176 1177func TestGroupInt64(t *testing.T) { 1178 v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} 1179 1180 grouped := v.GroupInt64(func(i int, val int64) string { 1181 return fmt.Sprintf("%v", i%2 == 0) 1182 }).data.(map[string][]int64) 1183 1184 assert.Equal(t, 2, len(grouped)) 1185 assert.Equal(t, 3, len(grouped["true"])) 1186 assert.Equal(t, 3, len(grouped["false"])) 1187} 1188 1189func TestReplaceInt64(t *testing.T) { 1190 v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} 1191 1192 rawArr := v.MustInt64Slice() 1193 1194 replaced := v.ReplaceInt64(func(index int, val int64) int64 { 1195 if index < len(rawArr)-1 { 1196 return rawArr[index+1] 1197 } 1198 return rawArr[0] 1199 }) 1200 1201 replacedArr := replaced.MustInt64Slice() 1202 if assert.Equal(t, 6, len(replacedArr)) { 1203 assert.Equal(t, replacedArr[0], rawArr[1]) 1204 assert.Equal(t, replacedArr[1], rawArr[2]) 1205 assert.Equal(t, replacedArr[2], rawArr[3]) 1206 assert.Equal(t, replacedArr[3], rawArr[4]) 1207 assert.Equal(t, replacedArr[4], rawArr[5]) 1208 assert.Equal(t, replacedArr[5], rawArr[0]) 1209 } 1210} 1211 1212func TestCollectInt64(t *testing.T) { 1213 v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} 1214 1215 collected := v.CollectInt64(func(index int, val int64) interface{} { 1216 return index 1217 }) 1218 1219 collectedArr := collected.MustInterSlice() 1220 if assert.Equal(t, 6, len(collectedArr)) { 1221 assert.Equal(t, collectedArr[0], 0) 1222 assert.Equal(t, collectedArr[1], 1) 1223 assert.Equal(t, collectedArr[2], 2) 1224 assert.Equal(t, collectedArr[3], 3) 1225 assert.Equal(t, collectedArr[4], 4) 1226 assert.Equal(t, collectedArr[5], 5) 1227 } 1228} 1229 1230/* 1231 Tests for Uint (uint and []uint) 1232*/ 1233 1234func TestUint(t *testing.T) { 1235 val := uint(1) 1236 1237 m := map[string]interface{}{"value": val, "nothing": nil} 1238 assert.Equal(t, val, New(m).Get("value").Uint()) 1239 assert.Equal(t, val, New(m).Get("value").MustUint()) 1240 assert.Equal(t, uint(0), New(m).Get("nothing").Uint()) 1241 assert.Equal(t, val, New(m).Get("nothing").Uint(1)) 1242 assert.Panics(t, func() { 1243 New(m).Get("age").MustUint() 1244 }) 1245} 1246 1247func TestUintSlice(t *testing.T) { 1248 val := uint(1) 1249 1250 m := map[string]interface{}{"value": []uint{val}, "nothing": nil} 1251 assert.Equal(t, val, New(m).Get("value").UintSlice()[0]) 1252 assert.Equal(t, val, New(m).Get("value").MustUintSlice()[0]) 1253 assert.Equal(t, []uint(nil), New(m).Get("nothing").UintSlice()) 1254 assert.Equal(t, val, New(m).Get("nothing").UintSlice([]uint{uint(1)})[0]) 1255 assert.Panics(t, func() { 1256 New(m).Get("nothing").MustUintSlice() 1257 }) 1258} 1259 1260func TestIsUint(t *testing.T) { 1261 v := &Value{data: uint(1)} 1262 assert.True(t, v.IsUint()) 1263 1264} 1265 1266func TestIsUintSlice(t *testing.T) { 1267 v := &Value{data: []uint{uint(1)}} 1268 assert.True(t, v.IsUintSlice()) 1269} 1270 1271func TestEachUint(t *testing.T) { 1272 v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1)}} 1273 count := 0 1274 replacedVals := make([]uint, 0) 1275 assert.Equal(t, v, v.EachUint(func(i int, val uint) bool { 1276 count++ 1277 replacedVals = append(replacedVals, val) 1278 1279 // abort early 1280 return i != 2 1281 })) 1282 1283 assert.Equal(t, count, 3) 1284 assert.Equal(t, replacedVals[0], v.MustUintSlice()[0]) 1285 assert.Equal(t, replacedVals[1], v.MustUintSlice()[1]) 1286 assert.Equal(t, replacedVals[2], v.MustUintSlice()[2]) 1287} 1288 1289func TestWhereUint(t *testing.T) { 1290 v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} 1291 1292 selected := v.WhereUint(func(i int, val uint) bool { 1293 return i%2 == 0 1294 }).MustUintSlice() 1295 1296 assert.Equal(t, 3, len(selected)) 1297} 1298 1299func TestGroupUint(t *testing.T) { 1300 v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} 1301 1302 grouped := v.GroupUint(func(i int, val uint) string { 1303 return fmt.Sprintf("%v", i%2 == 0) 1304 }).data.(map[string][]uint) 1305 1306 assert.Equal(t, 2, len(grouped)) 1307 assert.Equal(t, 3, len(grouped["true"])) 1308 assert.Equal(t, 3, len(grouped["false"])) 1309} 1310 1311func TestReplaceUint(t *testing.T) { 1312 v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} 1313 1314 rawArr := v.MustUintSlice() 1315 1316 replaced := v.ReplaceUint(func(index int, val uint) uint { 1317 if index < len(rawArr)-1 { 1318 return rawArr[index+1] 1319 } 1320 return rawArr[0] 1321 }) 1322 1323 replacedArr := replaced.MustUintSlice() 1324 if assert.Equal(t, 6, len(replacedArr)) { 1325 assert.Equal(t, replacedArr[0], rawArr[1]) 1326 assert.Equal(t, replacedArr[1], rawArr[2]) 1327 assert.Equal(t, replacedArr[2], rawArr[3]) 1328 assert.Equal(t, replacedArr[3], rawArr[4]) 1329 assert.Equal(t, replacedArr[4], rawArr[5]) 1330 assert.Equal(t, replacedArr[5], rawArr[0]) 1331 } 1332} 1333 1334func TestCollectUint(t *testing.T) { 1335 v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} 1336 1337 collected := v.CollectUint(func(index int, val uint) interface{} { 1338 return index 1339 }) 1340 1341 collectedArr := collected.MustInterSlice() 1342 if assert.Equal(t, 6, len(collectedArr)) { 1343 assert.Equal(t, collectedArr[0], 0) 1344 assert.Equal(t, collectedArr[1], 1) 1345 assert.Equal(t, collectedArr[2], 2) 1346 assert.Equal(t, collectedArr[3], 3) 1347 assert.Equal(t, collectedArr[4], 4) 1348 assert.Equal(t, collectedArr[5], 5) 1349 } 1350} 1351 1352/* 1353 Tests for Uint8 (uint8 and []uint8) 1354*/ 1355 1356func TestUint8(t *testing.T) { 1357 val := uint8(1) 1358 1359 m := map[string]interface{}{"value": val, "nothing": nil} 1360 assert.Equal(t, val, New(m).Get("value").Uint8()) 1361 assert.Equal(t, val, New(m).Get("value").MustUint8()) 1362 assert.Equal(t, uint8(0), New(m).Get("nothing").Uint8()) 1363 assert.Equal(t, val, New(m).Get("nothing").Uint8(1)) 1364 assert.Panics(t, func() { 1365 New(m).Get("age").MustUint8() 1366 }) 1367} 1368 1369func TestUint8Slice(t *testing.T) { 1370 val := uint8(1) 1371 1372 m := map[string]interface{}{"value": []uint8{val}, "nothing": nil} 1373 assert.Equal(t, val, New(m).Get("value").Uint8Slice()[0]) 1374 assert.Equal(t, val, New(m).Get("value").MustUint8Slice()[0]) 1375 assert.Equal(t, []uint8(nil), New(m).Get("nothing").Uint8Slice()) 1376 assert.Equal(t, val, New(m).Get("nothing").Uint8Slice([]uint8{uint8(1)})[0]) 1377 assert.Panics(t, func() { 1378 New(m).Get("nothing").MustUint8Slice() 1379 }) 1380} 1381 1382func TestIsUint8(t *testing.T) { 1383 v := &Value{data: uint8(1)} 1384 assert.True(t, v.IsUint8()) 1385 1386} 1387 1388func TestIsUint8Slice(t *testing.T) { 1389 v := &Value{data: []uint8{uint8(1)}} 1390 assert.True(t, v.IsUint8Slice()) 1391} 1392 1393func TestEachUint8(t *testing.T) { 1394 v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} 1395 count := 0 1396 replacedVals := make([]uint8, 0) 1397 assert.Equal(t, v, v.EachUint8(func(i int, val uint8) bool { 1398 count++ 1399 replacedVals = append(replacedVals, val) 1400 1401 // abort early 1402 return i != 2 1403 })) 1404 1405 assert.Equal(t, count, 3) 1406 assert.Equal(t, replacedVals[0], v.MustUint8Slice()[0]) 1407 assert.Equal(t, replacedVals[1], v.MustUint8Slice()[1]) 1408 assert.Equal(t, replacedVals[2], v.MustUint8Slice()[2]) 1409} 1410 1411func TestWhereUint8(t *testing.T) { 1412 v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} 1413 1414 selected := v.WhereUint8(func(i int, val uint8) bool { 1415 return i%2 == 0 1416 }).MustUint8Slice() 1417 1418 assert.Equal(t, 3, len(selected)) 1419} 1420 1421func TestGroupUint8(t *testing.T) { 1422 v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} 1423 1424 grouped := v.GroupUint8(func(i int, val uint8) string { 1425 return fmt.Sprintf("%v", i%2 == 0) 1426 }).data.(map[string][]uint8) 1427 1428 assert.Equal(t, 2, len(grouped)) 1429 assert.Equal(t, 3, len(grouped["true"])) 1430 assert.Equal(t, 3, len(grouped["false"])) 1431} 1432 1433func TestReplaceUint8(t *testing.T) { 1434 v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} 1435 1436 rawArr := v.MustUint8Slice() 1437 1438 replaced := v.ReplaceUint8(func(index int, val uint8) uint8 { 1439 if index < len(rawArr)-1 { 1440 return rawArr[index+1] 1441 } 1442 return rawArr[0] 1443 }) 1444 1445 replacedArr := replaced.MustUint8Slice() 1446 if assert.Equal(t, 6, len(replacedArr)) { 1447 assert.Equal(t, replacedArr[0], rawArr[1]) 1448 assert.Equal(t, replacedArr[1], rawArr[2]) 1449 assert.Equal(t, replacedArr[2], rawArr[3]) 1450 assert.Equal(t, replacedArr[3], rawArr[4]) 1451 assert.Equal(t, replacedArr[4], rawArr[5]) 1452 assert.Equal(t, replacedArr[5], rawArr[0]) 1453 } 1454} 1455 1456func TestCollectUint8(t *testing.T) { 1457 v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} 1458 1459 collected := v.CollectUint8(func(index int, val uint8) interface{} { 1460 return index 1461 }) 1462 1463 collectedArr := collected.MustInterSlice() 1464 if assert.Equal(t, 6, len(collectedArr)) { 1465 assert.Equal(t, collectedArr[0], 0) 1466 assert.Equal(t, collectedArr[1], 1) 1467 assert.Equal(t, collectedArr[2], 2) 1468 assert.Equal(t, collectedArr[3], 3) 1469 assert.Equal(t, collectedArr[4], 4) 1470 assert.Equal(t, collectedArr[5], 5) 1471 } 1472} 1473 1474/* 1475 Tests for Uint16 (uint16 and []uint16) 1476*/ 1477 1478func TestUint16(t *testing.T) { 1479 val := uint16(1) 1480 1481 m := map[string]interface{}{"value": val, "nothing": nil} 1482 assert.Equal(t, val, New(m).Get("value").Uint16()) 1483 assert.Equal(t, val, New(m).Get("value").MustUint16()) 1484 assert.Equal(t, uint16(0), New(m).Get("nothing").Uint16()) 1485 assert.Equal(t, val, New(m).Get("nothing").Uint16(1)) 1486 assert.Panics(t, func() { 1487 New(m).Get("age").MustUint16() 1488 }) 1489} 1490 1491func TestUint16Slice(t *testing.T) { 1492 val := uint16(1) 1493 1494 m := map[string]interface{}{"value": []uint16{val}, "nothing": nil} 1495 assert.Equal(t, val, New(m).Get("value").Uint16Slice()[0]) 1496 assert.Equal(t, val, New(m).Get("value").MustUint16Slice()[0]) 1497 assert.Equal(t, []uint16(nil), New(m).Get("nothing").Uint16Slice()) 1498 assert.Equal(t, val, New(m).Get("nothing").Uint16Slice([]uint16{uint16(1)})[0]) 1499 assert.Panics(t, func() { 1500 New(m).Get("nothing").MustUint16Slice() 1501 }) 1502} 1503 1504func TestIsUint16(t *testing.T) { 1505 v := &Value{data: uint16(1)} 1506 assert.True(t, v.IsUint16()) 1507 1508} 1509 1510func TestIsUint16Slice(t *testing.T) { 1511 v := &Value{data: []uint16{uint16(1)}} 1512 assert.True(t, v.IsUint16Slice()) 1513} 1514 1515func TestEachUint16(t *testing.T) { 1516 v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} 1517 count := 0 1518 replacedVals := make([]uint16, 0) 1519 assert.Equal(t, v, v.EachUint16(func(i int, val uint16) bool { 1520 count++ 1521 replacedVals = append(replacedVals, val) 1522 1523 // abort early 1524 return i != 2 1525 })) 1526 1527 assert.Equal(t, count, 3) 1528 assert.Equal(t, replacedVals[0], v.MustUint16Slice()[0]) 1529 assert.Equal(t, replacedVals[1], v.MustUint16Slice()[1]) 1530 assert.Equal(t, replacedVals[2], v.MustUint16Slice()[2]) 1531} 1532 1533func TestWhereUint16(t *testing.T) { 1534 v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} 1535 1536 selected := v.WhereUint16(func(i int, val uint16) bool { 1537 return i%2 == 0 1538 }).MustUint16Slice() 1539 1540 assert.Equal(t, 3, len(selected)) 1541} 1542 1543func TestGroupUint16(t *testing.T) { 1544 v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} 1545 1546 grouped := v.GroupUint16(func(i int, val uint16) string { 1547 return fmt.Sprintf("%v", i%2 == 0) 1548 }).data.(map[string][]uint16) 1549 1550 assert.Equal(t, 2, len(grouped)) 1551 assert.Equal(t, 3, len(grouped["true"])) 1552 assert.Equal(t, 3, len(grouped["false"])) 1553} 1554 1555func TestReplaceUint16(t *testing.T) { 1556 v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} 1557 1558 rawArr := v.MustUint16Slice() 1559 1560 replaced := v.ReplaceUint16(func(index int, val uint16) uint16 { 1561 if index < len(rawArr)-1 { 1562 return rawArr[index+1] 1563 } 1564 return rawArr[0] 1565 }) 1566 1567 replacedArr := replaced.MustUint16Slice() 1568 if assert.Equal(t, 6, len(replacedArr)) { 1569 assert.Equal(t, replacedArr[0], rawArr[1]) 1570 assert.Equal(t, replacedArr[1], rawArr[2]) 1571 assert.Equal(t, replacedArr[2], rawArr[3]) 1572 assert.Equal(t, replacedArr[3], rawArr[4]) 1573 assert.Equal(t, replacedArr[4], rawArr[5]) 1574 assert.Equal(t, replacedArr[5], rawArr[0]) 1575 } 1576} 1577 1578func TestCollectUint16(t *testing.T) { 1579 v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} 1580 1581 collected := v.CollectUint16(func(index int, val uint16) interface{} { 1582 return index 1583 }) 1584 1585 collectedArr := collected.MustInterSlice() 1586 if assert.Equal(t, 6, len(collectedArr)) { 1587 assert.Equal(t, collectedArr[0], 0) 1588 assert.Equal(t, collectedArr[1], 1) 1589 assert.Equal(t, collectedArr[2], 2) 1590 assert.Equal(t, collectedArr[3], 3) 1591 assert.Equal(t, collectedArr[4], 4) 1592 assert.Equal(t, collectedArr[5], 5) 1593 } 1594} 1595 1596/* 1597 Tests for Uint32 (uint32 and []uint32) 1598*/ 1599 1600func TestUint32(t *testing.T) { 1601 val := uint32(1) 1602 1603 m := map[string]interface{}{"value": val, "nothing": nil} 1604 assert.Equal(t, val, New(m).Get("value").Uint32()) 1605 assert.Equal(t, val, New(m).Get("value").MustUint32()) 1606 assert.Equal(t, uint32(0), New(m).Get("nothing").Uint32()) 1607 assert.Equal(t, val, New(m).Get("nothing").Uint32(1)) 1608 assert.Panics(t, func() { 1609 New(m).Get("age").MustUint32() 1610 }) 1611} 1612 1613func TestUint32Slice(t *testing.T) { 1614 val := uint32(1) 1615 1616 m := map[string]interface{}{"value": []uint32{val}, "nothing": nil} 1617 assert.Equal(t, val, New(m).Get("value").Uint32Slice()[0]) 1618 assert.Equal(t, val, New(m).Get("value").MustUint32Slice()[0]) 1619 assert.Equal(t, []uint32(nil), New(m).Get("nothing").Uint32Slice()) 1620 assert.Equal(t, val, New(m).Get("nothing").Uint32Slice([]uint32{uint32(1)})[0]) 1621 assert.Panics(t, func() { 1622 New(m).Get("nothing").MustUint32Slice() 1623 }) 1624} 1625 1626func TestIsUint32(t *testing.T) { 1627 v := &Value{data: uint32(1)} 1628 assert.True(t, v.IsUint32()) 1629 1630} 1631 1632func TestIsUint32Slice(t *testing.T) { 1633 v := &Value{data: []uint32{uint32(1)}} 1634 assert.True(t, v.IsUint32Slice()) 1635} 1636 1637func TestEachUint32(t *testing.T) { 1638 v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} 1639 count := 0 1640 replacedVals := make([]uint32, 0) 1641 assert.Equal(t, v, v.EachUint32(func(i int, val uint32) bool { 1642 count++ 1643 replacedVals = append(replacedVals, val) 1644 1645 // abort early 1646 return i != 2 1647 })) 1648 1649 assert.Equal(t, count, 3) 1650 assert.Equal(t, replacedVals[0], v.MustUint32Slice()[0]) 1651 assert.Equal(t, replacedVals[1], v.MustUint32Slice()[1]) 1652 assert.Equal(t, replacedVals[2], v.MustUint32Slice()[2]) 1653} 1654 1655func TestWhereUint32(t *testing.T) { 1656 v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} 1657 1658 selected := v.WhereUint32(func(i int, val uint32) bool { 1659 return i%2 == 0 1660 }).MustUint32Slice() 1661 1662 assert.Equal(t, 3, len(selected)) 1663} 1664 1665func TestGroupUint32(t *testing.T) { 1666 v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} 1667 1668 grouped := v.GroupUint32(func(i int, val uint32) string { 1669 return fmt.Sprintf("%v", i%2 == 0) 1670 }).data.(map[string][]uint32) 1671 1672 assert.Equal(t, 2, len(grouped)) 1673 assert.Equal(t, 3, len(grouped["true"])) 1674 assert.Equal(t, 3, len(grouped["false"])) 1675} 1676 1677func TestReplaceUint32(t *testing.T) { 1678 v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} 1679 1680 rawArr := v.MustUint32Slice() 1681 1682 replaced := v.ReplaceUint32(func(index int, val uint32) uint32 { 1683 if index < len(rawArr)-1 { 1684 return rawArr[index+1] 1685 } 1686 return rawArr[0] 1687 }) 1688 1689 replacedArr := replaced.MustUint32Slice() 1690 if assert.Equal(t, 6, len(replacedArr)) { 1691 assert.Equal(t, replacedArr[0], rawArr[1]) 1692 assert.Equal(t, replacedArr[1], rawArr[2]) 1693 assert.Equal(t, replacedArr[2], rawArr[3]) 1694 assert.Equal(t, replacedArr[3], rawArr[4]) 1695 assert.Equal(t, replacedArr[4], rawArr[5]) 1696 assert.Equal(t, replacedArr[5], rawArr[0]) 1697 } 1698} 1699 1700func TestCollectUint32(t *testing.T) { 1701 v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} 1702 1703 collected := v.CollectUint32(func(index int, val uint32) interface{} { 1704 return index 1705 }) 1706 1707 collectedArr := collected.MustInterSlice() 1708 if assert.Equal(t, 6, len(collectedArr)) { 1709 assert.Equal(t, collectedArr[0], 0) 1710 assert.Equal(t, collectedArr[1], 1) 1711 assert.Equal(t, collectedArr[2], 2) 1712 assert.Equal(t, collectedArr[3], 3) 1713 assert.Equal(t, collectedArr[4], 4) 1714 assert.Equal(t, collectedArr[5], 5) 1715 } 1716} 1717 1718/* 1719 Tests for Uint64 (uint64 and []uint64) 1720*/ 1721 1722func TestUint64(t *testing.T) { 1723 val := uint64(1) 1724 1725 m := map[string]interface{}{"value": val, "nothing": nil} 1726 assert.Equal(t, val, New(m).Get("value").Uint64()) 1727 assert.Equal(t, val, New(m).Get("value").MustUint64()) 1728 assert.Equal(t, uint64(0), New(m).Get("nothing").Uint64()) 1729 assert.Equal(t, val, New(m).Get("nothing").Uint64(1)) 1730 assert.Panics(t, func() { 1731 New(m).Get("age").MustUint64() 1732 }) 1733} 1734 1735func TestUint64Slice(t *testing.T) { 1736 val := uint64(1) 1737 1738 m := map[string]interface{}{"value": []uint64{val}, "nothing": nil} 1739 assert.Equal(t, val, New(m).Get("value").Uint64Slice()[0]) 1740 assert.Equal(t, val, New(m).Get("value").MustUint64Slice()[0]) 1741 assert.Equal(t, []uint64(nil), New(m).Get("nothing").Uint64Slice()) 1742 assert.Equal(t, val, New(m).Get("nothing").Uint64Slice([]uint64{uint64(1)})[0]) 1743 assert.Panics(t, func() { 1744 New(m).Get("nothing").MustUint64Slice() 1745 }) 1746} 1747 1748func TestIsUint64(t *testing.T) { 1749 v := &Value{data: uint64(1)} 1750 assert.True(t, v.IsUint64()) 1751 1752} 1753 1754func TestIsUint64Slice(t *testing.T) { 1755 v := &Value{data: []uint64{uint64(1)}} 1756 assert.True(t, v.IsUint64Slice()) 1757} 1758 1759func TestEachUint64(t *testing.T) { 1760 v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} 1761 count := 0 1762 replacedVals := make([]uint64, 0) 1763 assert.Equal(t, v, v.EachUint64(func(i int, val uint64) bool { 1764 count++ 1765 replacedVals = append(replacedVals, val) 1766 1767 // abort early 1768 return i != 2 1769 })) 1770 1771 assert.Equal(t, count, 3) 1772 assert.Equal(t, replacedVals[0], v.MustUint64Slice()[0]) 1773 assert.Equal(t, replacedVals[1], v.MustUint64Slice()[1]) 1774 assert.Equal(t, replacedVals[2], v.MustUint64Slice()[2]) 1775} 1776 1777func TestWhereUint64(t *testing.T) { 1778 v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} 1779 1780 selected := v.WhereUint64(func(i int, val uint64) bool { 1781 return i%2 == 0 1782 }).MustUint64Slice() 1783 1784 assert.Equal(t, 3, len(selected)) 1785} 1786 1787func TestGroupUint64(t *testing.T) { 1788 v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} 1789 1790 grouped := v.GroupUint64(func(i int, val uint64) string { 1791 return fmt.Sprintf("%v", i%2 == 0) 1792 }).data.(map[string][]uint64) 1793 1794 assert.Equal(t, 2, len(grouped)) 1795 assert.Equal(t, 3, len(grouped["true"])) 1796 assert.Equal(t, 3, len(grouped["false"])) 1797} 1798 1799func TestReplaceUint64(t *testing.T) { 1800 v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} 1801 1802 rawArr := v.MustUint64Slice() 1803 1804 replaced := v.ReplaceUint64(func(index int, val uint64) uint64 { 1805 if index < len(rawArr)-1 { 1806 return rawArr[index+1] 1807 } 1808 return rawArr[0] 1809 }) 1810 1811 replacedArr := replaced.MustUint64Slice() 1812 if assert.Equal(t, 6, len(replacedArr)) { 1813 assert.Equal(t, replacedArr[0], rawArr[1]) 1814 assert.Equal(t, replacedArr[1], rawArr[2]) 1815 assert.Equal(t, replacedArr[2], rawArr[3]) 1816 assert.Equal(t, replacedArr[3], rawArr[4]) 1817 assert.Equal(t, replacedArr[4], rawArr[5]) 1818 assert.Equal(t, replacedArr[5], rawArr[0]) 1819 } 1820} 1821 1822func TestCollectUint64(t *testing.T) { 1823 v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} 1824 1825 collected := v.CollectUint64(func(index int, val uint64) interface{} { 1826 return index 1827 }) 1828 1829 collectedArr := collected.MustInterSlice() 1830 if assert.Equal(t, 6, len(collectedArr)) { 1831 assert.Equal(t, collectedArr[0], 0) 1832 assert.Equal(t, collectedArr[1], 1) 1833 assert.Equal(t, collectedArr[2], 2) 1834 assert.Equal(t, collectedArr[3], 3) 1835 assert.Equal(t, collectedArr[4], 4) 1836 assert.Equal(t, collectedArr[5], 5) 1837 } 1838} 1839 1840/* 1841 Tests for Uintptr (uintptr and []uintptr) 1842*/ 1843 1844func TestUintptr(t *testing.T) { 1845 val := uintptr(1) 1846 1847 m := map[string]interface{}{"value": val, "nothing": nil} 1848 assert.Equal(t, val, New(m).Get("value").Uintptr()) 1849 assert.Equal(t, val, New(m).Get("value").MustUintptr()) 1850 assert.Equal(t, uintptr(0), New(m).Get("nothing").Uintptr()) 1851 assert.Equal(t, val, New(m).Get("nothing").Uintptr(1)) 1852 assert.Panics(t, func() { 1853 New(m).Get("age").MustUintptr() 1854 }) 1855} 1856 1857func TestUintptrSlice(t *testing.T) { 1858 val := uintptr(1) 1859 1860 m := map[string]interface{}{"value": []uintptr{val}, "nothing": nil} 1861 assert.Equal(t, val, New(m).Get("value").UintptrSlice()[0]) 1862 assert.Equal(t, val, New(m).Get("value").MustUintptrSlice()[0]) 1863 assert.Equal(t, []uintptr(nil), New(m).Get("nothing").UintptrSlice()) 1864 assert.Equal(t, val, New(m).Get("nothing").UintptrSlice([]uintptr{uintptr(1)})[0]) 1865 assert.Panics(t, func() { 1866 New(m).Get("nothing").MustUintptrSlice() 1867 }) 1868} 1869 1870func TestIsUintptr(t *testing.T) { 1871 v := &Value{data: uintptr(1)} 1872 assert.True(t, v.IsUintptr()) 1873 1874} 1875 1876func TestIsUintptrSlice(t *testing.T) { 1877 v := &Value{data: []uintptr{uintptr(1)}} 1878 assert.True(t, v.IsUintptrSlice()) 1879} 1880 1881func TestEachUintptr(t *testing.T) { 1882 v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} 1883 count := 0 1884 replacedVals := make([]uintptr, 0) 1885 assert.Equal(t, v, v.EachUintptr(func(i int, val uintptr) bool { 1886 count++ 1887 replacedVals = append(replacedVals, val) 1888 1889 // abort early 1890 return i != 2 1891 })) 1892 1893 assert.Equal(t, count, 3) 1894 assert.Equal(t, replacedVals[0], v.MustUintptrSlice()[0]) 1895 assert.Equal(t, replacedVals[1], v.MustUintptrSlice()[1]) 1896 assert.Equal(t, replacedVals[2], v.MustUintptrSlice()[2]) 1897} 1898 1899func TestWhereUintptr(t *testing.T) { 1900 v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} 1901 1902 selected := v.WhereUintptr(func(i int, val uintptr) bool { 1903 return i%2 == 0 1904 }).MustUintptrSlice() 1905 1906 assert.Equal(t, 3, len(selected)) 1907} 1908 1909func TestGroupUintptr(t *testing.T) { 1910 v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} 1911 1912 grouped := v.GroupUintptr(func(i int, val uintptr) string { 1913 return fmt.Sprintf("%v", i%2 == 0) 1914 }).data.(map[string][]uintptr) 1915 1916 assert.Equal(t, 2, len(grouped)) 1917 assert.Equal(t, 3, len(grouped["true"])) 1918 assert.Equal(t, 3, len(grouped["false"])) 1919} 1920 1921func TestReplaceUintptr(t *testing.T) { 1922 v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} 1923 1924 rawArr := v.MustUintptrSlice() 1925 1926 replaced := v.ReplaceUintptr(func(index int, val uintptr) uintptr { 1927 if index < len(rawArr)-1 { 1928 return rawArr[index+1] 1929 } 1930 return rawArr[0] 1931 }) 1932 1933 replacedArr := replaced.MustUintptrSlice() 1934 if assert.Equal(t, 6, len(replacedArr)) { 1935 assert.Equal(t, replacedArr[0], rawArr[1]) 1936 assert.Equal(t, replacedArr[1], rawArr[2]) 1937 assert.Equal(t, replacedArr[2], rawArr[3]) 1938 assert.Equal(t, replacedArr[3], rawArr[4]) 1939 assert.Equal(t, replacedArr[4], rawArr[5]) 1940 assert.Equal(t, replacedArr[5], rawArr[0]) 1941 } 1942} 1943 1944func TestCollectUintptr(t *testing.T) { 1945 v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} 1946 1947 collected := v.CollectUintptr(func(index int, val uintptr) interface{} { 1948 return index 1949 }) 1950 1951 collectedArr := collected.MustInterSlice() 1952 if assert.Equal(t, 6, len(collectedArr)) { 1953 assert.Equal(t, collectedArr[0], 0) 1954 assert.Equal(t, collectedArr[1], 1) 1955 assert.Equal(t, collectedArr[2], 2) 1956 assert.Equal(t, collectedArr[3], 3) 1957 assert.Equal(t, collectedArr[4], 4) 1958 assert.Equal(t, collectedArr[5], 5) 1959 } 1960} 1961 1962/* 1963 Tests for Float32 (float32 and []float32) 1964*/ 1965 1966func TestFloat32(t *testing.T) { 1967 val := float32(1) 1968 1969 m := map[string]interface{}{"value": val, "nothing": nil} 1970 assert.Equal(t, val, New(m).Get("value").Float32()) 1971 assert.Equal(t, val, New(m).Get("value").MustFloat32()) 1972 assert.Equal(t, float32(0), New(m).Get("nothing").Float32()) 1973 assert.Equal(t, val, New(m).Get("nothing").Float32(1)) 1974 assert.Panics(t, func() { 1975 New(m).Get("age").MustFloat32() 1976 }) 1977} 1978 1979func TestFloat32Slice(t *testing.T) { 1980 val := float32(1) 1981 1982 m := map[string]interface{}{"value": []float32{val}, "nothing": nil} 1983 assert.Equal(t, val, New(m).Get("value").Float32Slice()[0]) 1984 assert.Equal(t, val, New(m).Get("value").MustFloat32Slice()[0]) 1985 assert.Equal(t, []float32(nil), New(m).Get("nothing").Float32Slice()) 1986 assert.Equal(t, val, New(m).Get("nothing").Float32Slice([]float32{float32(1)})[0]) 1987 assert.Panics(t, func() { 1988 New(m).Get("nothing").MustFloat32Slice() 1989 }) 1990} 1991 1992func TestIsFloat32(t *testing.T) { 1993 v := &Value{data: float32(1)} 1994 assert.True(t, v.IsFloat32()) 1995 1996} 1997 1998func TestIsFloat32Slice(t *testing.T) { 1999 v := &Value{data: []float32{float32(1)}} 2000 assert.True(t, v.IsFloat32Slice()) 2001} 2002 2003func TestEachFloat32(t *testing.T) { 2004 v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1)}} 2005 count := 0 2006 replacedVals := make([]float32, 0) 2007 assert.Equal(t, v, v.EachFloat32(func(i int, val float32) bool { 2008 count++ 2009 replacedVals = append(replacedVals, val) 2010 2011 // abort early 2012 return i != 2 2013 })) 2014 2015 assert.Equal(t, count, 3) 2016 assert.Equal(t, replacedVals[0], v.MustFloat32Slice()[0]) 2017 assert.Equal(t, replacedVals[1], v.MustFloat32Slice()[1]) 2018 assert.Equal(t, replacedVals[2], v.MustFloat32Slice()[2]) 2019} 2020 2021func TestWhereFloat32(t *testing.T) { 2022 v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} 2023 2024 selected := v.WhereFloat32(func(i int, val float32) bool { 2025 return i%2 == 0 2026 }).MustFloat32Slice() 2027 2028 assert.Equal(t, 3, len(selected)) 2029} 2030 2031func TestGroupFloat32(t *testing.T) { 2032 v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} 2033 2034 grouped := v.GroupFloat32(func(i int, val float32) string { 2035 return fmt.Sprintf("%v", i%2 == 0) 2036 }).data.(map[string][]float32) 2037 2038 assert.Equal(t, 2, len(grouped)) 2039 assert.Equal(t, 3, len(grouped["true"])) 2040 assert.Equal(t, 3, len(grouped["false"])) 2041} 2042 2043func TestReplaceFloat32(t *testing.T) { 2044 v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} 2045 2046 rawArr := v.MustFloat32Slice() 2047 2048 replaced := v.ReplaceFloat32(func(index int, val float32) float32 { 2049 if index < len(rawArr)-1 { 2050 return rawArr[index+1] 2051 } 2052 return rawArr[0] 2053 }) 2054 2055 replacedArr := replaced.MustFloat32Slice() 2056 if assert.Equal(t, 6, len(replacedArr)) { 2057 assert.Equal(t, replacedArr[0], rawArr[1]) 2058 assert.Equal(t, replacedArr[1], rawArr[2]) 2059 assert.Equal(t, replacedArr[2], rawArr[3]) 2060 assert.Equal(t, replacedArr[3], rawArr[4]) 2061 assert.Equal(t, replacedArr[4], rawArr[5]) 2062 assert.Equal(t, replacedArr[5], rawArr[0]) 2063 } 2064} 2065 2066func TestCollectFloat32(t *testing.T) { 2067 v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} 2068 2069 collected := v.CollectFloat32(func(index int, val float32) interface{} { 2070 return index 2071 }) 2072 2073 collectedArr := collected.MustInterSlice() 2074 if assert.Equal(t, 6, len(collectedArr)) { 2075 assert.Equal(t, collectedArr[0], 0) 2076 assert.Equal(t, collectedArr[1], 1) 2077 assert.Equal(t, collectedArr[2], 2) 2078 assert.Equal(t, collectedArr[3], 3) 2079 assert.Equal(t, collectedArr[4], 4) 2080 assert.Equal(t, collectedArr[5], 5) 2081 } 2082} 2083 2084/* 2085 Tests for Float64 (float64 and []float64) 2086*/ 2087 2088func TestFloat64(t *testing.T) { 2089 val := float64(1) 2090 2091 m := map[string]interface{}{"value": val, "nothing": nil} 2092 assert.Equal(t, val, New(m).Get("value").Float64()) 2093 assert.Equal(t, val, New(m).Get("value").MustFloat64()) 2094 assert.Equal(t, float64(0), New(m).Get("nothing").Float64()) 2095 assert.Equal(t, val, New(m).Get("nothing").Float64(1)) 2096 assert.Panics(t, func() { 2097 New(m).Get("age").MustFloat64() 2098 }) 2099} 2100 2101func TestFloat64Slice(t *testing.T) { 2102 val := float64(1) 2103 2104 m := map[string]interface{}{"value": []float64{val}, "nothing": nil} 2105 assert.Equal(t, val, New(m).Get("value").Float64Slice()[0]) 2106 assert.Equal(t, val, New(m).Get("value").MustFloat64Slice()[0]) 2107 assert.Equal(t, []float64(nil), New(m).Get("nothing").Float64Slice()) 2108 assert.Equal(t, val, New(m).Get("nothing").Float64Slice([]float64{float64(1)})[0]) 2109 assert.Panics(t, func() { 2110 New(m).Get("nothing").MustFloat64Slice() 2111 }) 2112} 2113 2114func TestIsFloat64(t *testing.T) { 2115 v := &Value{data: float64(1)} 2116 assert.True(t, v.IsFloat64()) 2117 2118} 2119 2120func TestIsFloat64Slice(t *testing.T) { 2121 v := &Value{data: []float64{float64(1)}} 2122 assert.True(t, v.IsFloat64Slice()) 2123} 2124 2125func TestEachFloat64(t *testing.T) { 2126 v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1)}} 2127 count := 0 2128 replacedVals := make([]float64, 0) 2129 assert.Equal(t, v, v.EachFloat64(func(i int, val float64) bool { 2130 count++ 2131 replacedVals = append(replacedVals, val) 2132 2133 // abort early 2134 return i != 2 2135 })) 2136 2137 assert.Equal(t, count, 3) 2138 assert.Equal(t, replacedVals[0], v.MustFloat64Slice()[0]) 2139 assert.Equal(t, replacedVals[1], v.MustFloat64Slice()[1]) 2140 assert.Equal(t, replacedVals[2], v.MustFloat64Slice()[2]) 2141} 2142 2143func TestWhereFloat64(t *testing.T) { 2144 v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} 2145 2146 selected := v.WhereFloat64(func(i int, val float64) bool { 2147 return i%2 == 0 2148 }).MustFloat64Slice() 2149 2150 assert.Equal(t, 3, len(selected)) 2151} 2152 2153func TestGroupFloat64(t *testing.T) { 2154 v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} 2155 2156 grouped := v.GroupFloat64(func(i int, val float64) string { 2157 return fmt.Sprintf("%v", i%2 == 0) 2158 }).data.(map[string][]float64) 2159 2160 assert.Equal(t, 2, len(grouped)) 2161 assert.Equal(t, 3, len(grouped["true"])) 2162 assert.Equal(t, 3, len(grouped["false"])) 2163} 2164 2165func TestReplaceFloat64(t *testing.T) { 2166 v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} 2167 2168 rawArr := v.MustFloat64Slice() 2169 2170 replaced := v.ReplaceFloat64(func(index int, val float64) float64 { 2171 if index < len(rawArr)-1 { 2172 return rawArr[index+1] 2173 } 2174 return rawArr[0] 2175 }) 2176 2177 replacedArr := replaced.MustFloat64Slice() 2178 if assert.Equal(t, 6, len(replacedArr)) { 2179 assert.Equal(t, replacedArr[0], rawArr[1]) 2180 assert.Equal(t, replacedArr[1], rawArr[2]) 2181 assert.Equal(t, replacedArr[2], rawArr[3]) 2182 assert.Equal(t, replacedArr[3], rawArr[4]) 2183 assert.Equal(t, replacedArr[4], rawArr[5]) 2184 assert.Equal(t, replacedArr[5], rawArr[0]) 2185 } 2186} 2187 2188func TestCollectFloat64(t *testing.T) { 2189 v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} 2190 2191 collected := v.CollectFloat64(func(index int, val float64) interface{} { 2192 return index 2193 }) 2194 2195 collectedArr := collected.MustInterSlice() 2196 if assert.Equal(t, 6, len(collectedArr)) { 2197 assert.Equal(t, collectedArr[0], 0) 2198 assert.Equal(t, collectedArr[1], 1) 2199 assert.Equal(t, collectedArr[2], 2) 2200 assert.Equal(t, collectedArr[3], 3) 2201 assert.Equal(t, collectedArr[4], 4) 2202 assert.Equal(t, collectedArr[5], 5) 2203 } 2204} 2205 2206/* 2207 Tests for Complex64 (complex64 and []complex64) 2208*/ 2209 2210func TestComplex64(t *testing.T) { 2211 val := complex64(1) 2212 2213 m := map[string]interface{}{"value": val, "nothing": nil} 2214 assert.Equal(t, val, New(m).Get("value").Complex64()) 2215 assert.Equal(t, val, New(m).Get("value").MustComplex64()) 2216 assert.Equal(t, complex64(0), New(m).Get("nothing").Complex64()) 2217 assert.Equal(t, val, New(m).Get("nothing").Complex64(1)) 2218 assert.Panics(t, func() { 2219 New(m).Get("age").MustComplex64() 2220 }) 2221} 2222 2223func TestComplex64Slice(t *testing.T) { 2224 val := complex64(1) 2225 2226 m := map[string]interface{}{"value": []complex64{val}, "nothing": nil} 2227 assert.Equal(t, val, New(m).Get("value").Complex64Slice()[0]) 2228 assert.Equal(t, val, New(m).Get("value").MustComplex64Slice()[0]) 2229 assert.Equal(t, []complex64(nil), New(m).Get("nothing").Complex64Slice()) 2230 assert.Equal(t, val, New(m).Get("nothing").Complex64Slice([]complex64{complex64(1)})[0]) 2231 assert.Panics(t, func() { 2232 New(m).Get("nothing").MustComplex64Slice() 2233 }) 2234} 2235 2236func TestIsComplex64(t *testing.T) { 2237 v := &Value{data: complex64(1)} 2238 assert.True(t, v.IsComplex64()) 2239 2240} 2241 2242func TestIsComplex64Slice(t *testing.T) { 2243 v := &Value{data: []complex64{complex64(1)}} 2244 assert.True(t, v.IsComplex64Slice()) 2245} 2246 2247func TestEachComplex64(t *testing.T) { 2248 v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} 2249 count := 0 2250 replacedVals := make([]complex64, 0) 2251 assert.Equal(t, v, v.EachComplex64(func(i int, val complex64) bool { 2252 count++ 2253 replacedVals = append(replacedVals, val) 2254 2255 // abort early 2256 return i != 2 2257 })) 2258 2259 assert.Equal(t, count, 3) 2260 assert.Equal(t, replacedVals[0], v.MustComplex64Slice()[0]) 2261 assert.Equal(t, replacedVals[1], v.MustComplex64Slice()[1]) 2262 assert.Equal(t, replacedVals[2], v.MustComplex64Slice()[2]) 2263} 2264 2265func TestWhereComplex64(t *testing.T) { 2266 v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} 2267 2268 selected := v.WhereComplex64(func(i int, val complex64) bool { 2269 return i%2 == 0 2270 }).MustComplex64Slice() 2271 2272 assert.Equal(t, 3, len(selected)) 2273} 2274 2275func TestGroupComplex64(t *testing.T) { 2276 v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} 2277 2278 grouped := v.GroupComplex64(func(i int, val complex64) string { 2279 return fmt.Sprintf("%v", i%2 == 0) 2280 }).data.(map[string][]complex64) 2281 2282 assert.Equal(t, 2, len(grouped)) 2283 assert.Equal(t, 3, len(grouped["true"])) 2284 assert.Equal(t, 3, len(grouped["false"])) 2285} 2286 2287func TestReplaceComplex64(t *testing.T) { 2288 v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} 2289 2290 rawArr := v.MustComplex64Slice() 2291 2292 replaced := v.ReplaceComplex64(func(index int, val complex64) complex64 { 2293 if index < len(rawArr)-1 { 2294 return rawArr[index+1] 2295 } 2296 return rawArr[0] 2297 }) 2298 2299 replacedArr := replaced.MustComplex64Slice() 2300 if assert.Equal(t, 6, len(replacedArr)) { 2301 assert.Equal(t, replacedArr[0], rawArr[1]) 2302 assert.Equal(t, replacedArr[1], rawArr[2]) 2303 assert.Equal(t, replacedArr[2], rawArr[3]) 2304 assert.Equal(t, replacedArr[3], rawArr[4]) 2305 assert.Equal(t, replacedArr[4], rawArr[5]) 2306 assert.Equal(t, replacedArr[5], rawArr[0]) 2307 } 2308} 2309 2310func TestCollectComplex64(t *testing.T) { 2311 v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} 2312 2313 collected := v.CollectComplex64(func(index int, val complex64) interface{} { 2314 return index 2315 }) 2316 2317 collectedArr := collected.MustInterSlice() 2318 if assert.Equal(t, 6, len(collectedArr)) { 2319 assert.Equal(t, collectedArr[0], 0) 2320 assert.Equal(t, collectedArr[1], 1) 2321 assert.Equal(t, collectedArr[2], 2) 2322 assert.Equal(t, collectedArr[3], 3) 2323 assert.Equal(t, collectedArr[4], 4) 2324 assert.Equal(t, collectedArr[5], 5) 2325 } 2326} 2327 2328/* 2329 Tests for Complex128 (complex128 and []complex128) 2330*/ 2331 2332func TestComplex128(t *testing.T) { 2333 val := complex128(1) 2334 2335 m := map[string]interface{}{"value": val, "nothing": nil} 2336 assert.Equal(t, val, New(m).Get("value").Complex128()) 2337 assert.Equal(t, val, New(m).Get("value").MustComplex128()) 2338 assert.Equal(t, complex128(0), New(m).Get("nothing").Complex128()) 2339 assert.Equal(t, val, New(m).Get("nothing").Complex128(1)) 2340 assert.Panics(t, func() { 2341 New(m).Get("age").MustComplex128() 2342 }) 2343} 2344 2345func TestComplex128Slice(t *testing.T) { 2346 val := complex128(1) 2347 2348 m := map[string]interface{}{"value": []complex128{val}, "nothing": nil} 2349 assert.Equal(t, val, New(m).Get("value").Complex128Slice()[0]) 2350 assert.Equal(t, val, New(m).Get("value").MustComplex128Slice()[0]) 2351 assert.Equal(t, []complex128(nil), New(m).Get("nothing").Complex128Slice()) 2352 assert.Equal(t, val, New(m).Get("nothing").Complex128Slice([]complex128{complex128(1)})[0]) 2353 assert.Panics(t, func() { 2354 New(m).Get("nothing").MustComplex128Slice() 2355 }) 2356} 2357 2358func TestIsComplex128(t *testing.T) { 2359 v := &Value{data: complex128(1)} 2360 assert.True(t, v.IsComplex128()) 2361 2362} 2363 2364func TestIsComplex128Slice(t *testing.T) { 2365 v := &Value{data: []complex128{complex128(1)}} 2366 assert.True(t, v.IsComplex128Slice()) 2367} 2368 2369func TestEachComplex128(t *testing.T) { 2370 v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} 2371 count := 0 2372 replacedVals := make([]complex128, 0) 2373 assert.Equal(t, v, v.EachComplex128(func(i int, val complex128) bool { 2374 count++ 2375 replacedVals = append(replacedVals, val) 2376 2377 // abort early 2378 return i != 2 2379 })) 2380 2381 assert.Equal(t, count, 3) 2382 assert.Equal(t, replacedVals[0], v.MustComplex128Slice()[0]) 2383 assert.Equal(t, replacedVals[1], v.MustComplex128Slice()[1]) 2384 assert.Equal(t, replacedVals[2], v.MustComplex128Slice()[2]) 2385} 2386 2387func TestWhereComplex128(t *testing.T) { 2388 v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} 2389 2390 selected := v.WhereComplex128(func(i int, val complex128) bool { 2391 return i%2 == 0 2392 }).MustComplex128Slice() 2393 2394 assert.Equal(t, 3, len(selected)) 2395} 2396 2397func TestGroupComplex128(t *testing.T) { 2398 v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} 2399 2400 grouped := v.GroupComplex128(func(i int, val complex128) string { 2401 return fmt.Sprintf("%v", i%2 == 0) 2402 }).data.(map[string][]complex128) 2403 2404 assert.Equal(t, 2, len(grouped)) 2405 assert.Equal(t, 3, len(grouped["true"])) 2406 assert.Equal(t, 3, len(grouped["false"])) 2407} 2408 2409func TestReplaceComplex128(t *testing.T) { 2410 v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} 2411 2412 rawArr := v.MustComplex128Slice() 2413 2414 replaced := v.ReplaceComplex128(func(index int, val complex128) complex128 { 2415 if index < len(rawArr)-1 { 2416 return rawArr[index+1] 2417 } 2418 return rawArr[0] 2419 }) 2420 2421 replacedArr := replaced.MustComplex128Slice() 2422 if assert.Equal(t, 6, len(replacedArr)) { 2423 assert.Equal(t, replacedArr[0], rawArr[1]) 2424 assert.Equal(t, replacedArr[1], rawArr[2]) 2425 assert.Equal(t, replacedArr[2], rawArr[3]) 2426 assert.Equal(t, replacedArr[3], rawArr[4]) 2427 assert.Equal(t, replacedArr[4], rawArr[5]) 2428 assert.Equal(t, replacedArr[5], rawArr[0]) 2429 } 2430} 2431 2432func TestCollectComplex128(t *testing.T) { 2433 v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} 2434 2435 collected := v.CollectComplex128(func(index int, val complex128) interface{} { 2436 return index 2437 }) 2438 2439 collectedArr := collected.MustInterSlice() 2440 if assert.Equal(t, 6, len(collectedArr)) { 2441 assert.Equal(t, collectedArr[0], 0) 2442 assert.Equal(t, collectedArr[1], 1) 2443 assert.Equal(t, collectedArr[2], 2) 2444 assert.Equal(t, collectedArr[3], 3) 2445 assert.Equal(t, collectedArr[4], 4) 2446 assert.Equal(t, collectedArr[5], 5) 2447 } 2448} 2449