vendor/github.com/spf13/cast/cast_test.go

   1 // Copyright © 2014 Steve Francia <spf@spf13.com>.
   2 //
   3 // Use of this source code is governed by an MIT-style
   4 // license that can be found in the LICENSE file.
   5
   6 package cast
   7
   8 import (
   9         "fmt"
  10         "html/template"
  11         "testing"
  12         "time"
  13
  14         "github.com/stretchr/testify/assert"
  15 )
  16
  17 func TestToUintE(t *testing.T) {
  18         tests := []struct {
  19                 input  interface{}
  20                 expect uint
  21                 iserr  bool
  22         }{
  23                 {int(8), 8, false},
  24                 {int8(8), 8, false},
  25                 {int16(8), 8, false},
  26                 {int32(8), 8, false},
  27                 {int64(8), 8, false},
  28                 {uint(8), 8, false},
  29                 {uint8(8), 8, false},
  30                 {uint16(8), 8, false},
  31                 {uint32(8), 8, false},
  32                 {uint64(8), 8, false},
  33                 {float32(8.31), 8, false},
  34                 {float64(8.31), 8, false},
  35                 {true, 1, false},
  36                 {false, 0, false},
  37                 {"8", 8, false},
  38                 {nil, 0, false},
  39                 // errors
  40                 {int(-8), 0, true},
  41                 {int8(-8), 0, true},
  42                 {int16(-8), 0, true},
  43                 {int32(-8), 0, true},
  44                 {int64(-8), 0, true},
  45                 {float32(-8.31), 0, true},
  46                 {float64(-8.31), 0, true},
  47                 {"-8", 0, true},
  48                 {"test", 0, true},
  49                 {testing.T{}, 0, true},
  50         }
  51
  52         for i, test := range tests {
  53                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
  54
  55                 v, err := ToUintE(test.input)
  56                 if test.iserr {
  57                         assert.Error(t, err, errmsg)
  58                         continue
  59                 }
  60
  61                 assert.NoError(t, err, errmsg)
  62                 assert.Equal(t, test.expect, v, errmsg)
  63
  64                 // Non-E test:
  65                 v = ToUint(test.input)
  66                 assert.Equal(t, test.expect, v, errmsg)
  67         }
  68 }
  69
  70 func TestToUint64E(t *testing.T) {
  71         tests := []struct {
  72                 input  interface{}
  73                 expect uint64
  74                 iserr  bool
  75         }{
  76                 {int(8), 8, false},
  77                 {int8(8), 8, false},
  78                 {int16(8), 8, false},
  79                 {int32(8), 8, false},
  80                 {int64(8), 8, false},
  81                 {uint(8), 8, false},
  82                 {uint8(8), 8, false},
  83                 {uint16(8), 8, false},
  84                 {uint32(8), 8, false},
  85                 {uint64(8), 8, false},
  86                 {float32(8.31), 8, false},
  87                 {float64(8.31), 8, false},
  88                 {true, 1, false},
  89                 {false, 0, false},
  90                 {"8", 8, false},
  91                 {nil, 0, false},
  92                 // errors
  93                 {int(-8), 0, true},
  94                 {int8(-8), 0, true},
  95                 {int16(-8), 0, true},
  96                 {int32(-8), 0, true},
  97                 {int64(-8), 0, true},
  98                 {float32(-8.31), 0, true},
  99                 {float64(-8.31), 0, true},
 100                 {"-8", 0, true},
 101                 {"test", 0, true},
 102                 {testing.T{}, 0, true},
 103         }
 104
 105         for i, test := range tests {
 106                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 107
 108                 v, err := ToUint64E(test.input)
 109                 if test.iserr {
 110                         assert.Error(t, err, errmsg)
 111                         continue
 112                 }
 113
 114                 assert.NoError(t, err, errmsg)
 115                 assert.Equal(t, test.expect, v, errmsg)
 116
 117                 // Non-E test:
 118                 v = ToUint64(test.input)
 119                 assert.Equal(t, test.expect, v, errmsg)
 120         }
 121 }
 122
 123 func TestToUint32E(t *testing.T) {
 124         tests := []struct {
 125                 input  interface{}
 126                 expect uint32
 127                 iserr  bool
 128         }{
 129                 {int(8), 8, false},
 130                 {int8(8), 8, false},
 131                 {int16(8), 8, false},
 132                 {int32(8), 8, false},
 133                 {int64(8), 8, false},
 134                 {uint(8), 8, false},
 135                 {uint8(8), 8, false},
 136                 {uint16(8), 8, false},
 137                 {uint32(8), 8, false},
 138                 {uint64(8), 8, false},
 139                 {float32(8.31), 8, false},
 140                 {float64(8.31), 8, false},
 141                 {true, 1, false},
 142                 {false, 0, false},
 143                 {"8", 8, false},
 144                 {nil, 0, false},
 145                 {int(-8), 0, true},
 146                 {int8(-8), 0, true},
 147                 {int16(-8), 0, true},
 148                 {int32(-8), 0, true},
 149                 {int64(-8), 0, true},
 150                 {float32(-8.31), 0, true},
 151                 {float64(-8.31), 0, true},
 152                 {"-8", 0, true},
 153                 // errors
 154                 {"test", 0, true},
 155                 {testing.T{}, 0, true},
 156         }
 157
 158         for i, test := range tests {
 159                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 160
 161                 v, err := ToUint32E(test.input)
 162                 if test.iserr {
 163                         assert.Error(t, err, errmsg)
 164                         continue
 165                 }
 166
 167                 assert.NoError(t, err, errmsg)
 168                 assert.Equal(t, test.expect, v, errmsg)
 169
 170                 // Non-E test:
 171                 v = ToUint32(test.input)
 172                 assert.Equal(t, test.expect, v, errmsg)
 173         }
 174 }
 175
 176 func TestToUint16E(t *testing.T) {
 177         tests := []struct {
 178                 input  interface{}
 179                 expect uint16
 180                 iserr  bool
 181         }{
 182                 {int(8), 8, false},
 183                 {int8(8), 8, false},
 184                 {int16(8), 8, false},
 185                 {int32(8), 8, false},
 186                 {int64(8), 8, false},
 187                 {uint(8), 8, false},
 188                 {uint8(8), 8, false},
 189                 {uint16(8), 8, false},
 190                 {uint32(8), 8, false},
 191                 {uint64(8), 8, false},
 192                 {float32(8.31), 8, false},
 193                 {float64(8.31), 8, false},
 194                 {true, 1, false},
 195                 {false, 0, false},
 196                 {"8", 8, false},
 197                 {nil, 0, false},
 198                 // errors
 199                 {int(-8), 0, true},
 200                 {int8(-8), 0, true},
 201                 {int16(-8), 0, true},
 202                 {int32(-8), 0, true},
 203                 {int64(-8), 0, true},
 204                 {float32(-8.31), 0, true},
 205                 {float64(-8.31), 0, true},
 206                 {"-8", 0, true},
 207                 {"test", 0, true},
 208                 {testing.T{}, 0, true},
 209         }
 210
 211         for i, test := range tests {
 212                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 213
 214                 v, err := ToUint16E(test.input)
 215                 if test.iserr {
 216                         assert.Error(t, err, errmsg)
 217                         continue
 218                 }
 219
 220                 assert.NoError(t, err, errmsg)
 221                 assert.Equal(t, test.expect, v, errmsg)
 222
 223                 // Non-E test
 224                 v = ToUint16(test.input)
 225                 assert.Equal(t, test.expect, v, errmsg)
 226         }
 227 }
 228
 229 func TestToUint8E(t *testing.T) {
 230         tests := []struct {
 231                 input  interface{}
 232                 expect uint8
 233                 iserr  bool
 234         }{
 235                 {int(8), 8, false},
 236                 {int8(8), 8, false},
 237                 {int16(8), 8, false},
 238                 {int32(8), 8, false},
 239                 {int64(8), 8, false},
 240                 {uint(8), 8, false},
 241                 {uint8(8), 8, false},
 242                 {uint16(8), 8, false},
 243                 {uint32(8), 8, false},
 244                 {uint64(8), 8, false},
 245                 {float32(8.31), 8, false},
 246                 {float64(8.31), 8, false},
 247                 {true, 1, false},
 248                 {false, 0, false},
 249                 {"8", 8, false},
 250                 {nil, 0, false},
 251                 // errors
 252                 {int(-8), 0, true},
 253                 {int8(-8), 0, true},
 254                 {int16(-8), 0, true},
 255                 {int32(-8), 0, true},
 256                 {int64(-8), 0, true},
 257                 {float32(-8.31), 0, true},
 258                 {float64(-8.31), 0, true},
 259                 {"-8", 0, true},
 260                 {"test", 0, true},
 261                 {testing.T{}, 0, true},
 262         }
 263
 264         for i, test := range tests {
 265                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 266
 267                 v, err := ToUint8E(test.input)
 268                 if test.iserr {
 269                         assert.Error(t, err, errmsg)
 270                         continue
 271                 }
 272
 273                 assert.NoError(t, err, errmsg)
 274                 assert.Equal(t, test.expect, v, errmsg)
 275
 276                 // Non-E test
 277                 v = ToUint8(test.input)
 278                 assert.Equal(t, test.expect, v, errmsg)
 279         }
 280 }
 281
 282 func TestToIntE(t *testing.T) {
 283         tests := []struct {
 284                 input  interface{}
 285                 expect int
 286                 iserr  bool
 287         }{
 288                 {int(8), 8, false},
 289                 {int8(8), 8, false},
 290                 {int16(8), 8, false},
 291                 {int32(8), 8, false},
 292                 {int64(8), 8, false},
 293                 {uint(8), 8, false},
 294                 {uint8(8), 8, false},
 295                 {uint16(8), 8, false},
 296                 {uint32(8), 8, false},
 297                 {uint64(8), 8, false},
 298                 {float32(8.31), 8, false},
 299                 {float64(8.31), 8, false},
 300                 {true, 1, false},
 301                 {false, 0, false},
 302                 {"8", 8, false},
 303                 {nil, 0, false},
 304                 // errors
 305                 {"test", 0, true},
 306                 {testing.T{}, 0, true},
 307         }
 308
 309         for i, test := range tests {
 310                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 311
 312                 v, err := ToIntE(test.input)
 313                 if test.iserr {
 314                         assert.Error(t, err, errmsg)
 315                         continue
 316                 }
 317
 318                 assert.NoError(t, err, errmsg)
 319                 assert.Equal(t, test.expect, v, errmsg)
 320
 321                 // Non-E test
 322                 v = ToInt(test.input)
 323                 assert.Equal(t, test.expect, v, errmsg)
 324         }
 325 }
 326
 327 func TestToInt64E(t *testing.T) {
 328         tests := []struct {
 329                 input  interface{}
 330                 expect int64
 331                 iserr  bool
 332         }{
 333                 {int(8), 8, false},
 334                 {int8(8), 8, false},
 335                 {int16(8), 8, false},
 336                 {int32(8), 8, false},
 337                 {int64(8), 8, false},
 338                 {uint(8), 8, false},
 339                 {uint8(8), 8, false},
 340                 {uint16(8), 8, false},
 341                 {uint32(8), 8, false},
 342                 {uint64(8), 8, false},
 343                 {float32(8.31), 8, false},
 344                 {float64(8.31), 8, false},
 345                 {true, 1, false},
 346                 {false, 0, false},
 347                 {"8", 8, false},
 348                 {nil, 0, false},
 349                 // errors
 350                 {"test", 0, true},
 351                 {testing.T{}, 0, true},
 352         }
 353
 354         for i, test := range tests {
 355                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 356
 357                 v, err := ToInt64E(test.input)
 358                 if test.iserr {
 359                         assert.Error(t, err, errmsg)
 360                         continue
 361                 }
 362
 363                 assert.NoError(t, err, errmsg)
 364                 assert.Equal(t, test.expect, v, errmsg)
 365
 366                 // Non-E test
 367                 v = ToInt64(test.input)
 368                 assert.Equal(t, test.expect, v, errmsg)
 369         }
 370 }
 371
 372 func TestToInt32E(t *testing.T) {
 373         tests := []struct {
 374                 input  interface{}
 375                 expect int32
 376                 iserr  bool
 377         }{
 378                 {int(8), 8, false},
 379                 {int8(8), 8, false},
 380                 {int16(8), 8, false},
 381                 {int32(8), 8, false},
 382                 {int64(8), 8, false},
 383                 {uint(8), 8, false},
 384                 {uint8(8), 8, false},
 385                 {uint16(8), 8, false},
 386                 {uint32(8), 8, false},
 387                 {uint64(8), 8, false},
 388                 {float32(8.31), 8, false},
 389                 {float64(8.31), 8, false},
 390                 {true, 1, false},
 391                 {false, 0, false},
 392                 {"8", 8, false},
 393                 {nil, 0, false},
 394                 // errors
 395                 {"test", 0, true},
 396                 {testing.T{}, 0, true},
 397         }
 398
 399         for i, test := range tests {
 400                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 401
 402                 v, err := ToInt32E(test.input)
 403                 if test.iserr {
 404                         assert.Error(t, err, errmsg)
 405                         continue
 406                 }
 407
 408                 assert.NoError(t, err, errmsg)
 409                 assert.Equal(t, test.expect, v, errmsg)
 410
 411                 // Non-E test
 412                 v = ToInt32(test.input)
 413                 assert.Equal(t, test.expect, v, errmsg)
 414         }
 415 }
 416
 417 func TestToInt16E(t *testing.T) {
 418         tests := []struct {
 419                 input  interface{}
 420                 expect int16
 421                 iserr  bool
 422         }{
 423                 {int(8), 8, false},
 424                 {int8(8), 8, false},
 425                 {int16(8), 8, false},
 426                 {int32(8), 8, false},
 427                 {int64(8), 8, false},
 428                 {uint(8), 8, false},
 429                 {uint8(8), 8, false},
 430                 {uint16(8), 8, false},
 431                 {uint32(8), 8, false},
 432                 {uint64(8), 8, false},
 433                 {float32(8.31), 8, false},
 434                 {float64(8.31), 8, false},
 435                 {true, 1, false},
 436                 {false, 0, false},
 437                 {"8", 8, false},
 438                 {nil, 0, false},
 439                 // errors
 440                 {"test", 0, true},
 441                 {testing.T{}, 0, true},
 442         }
 443
 444         for i, test := range tests {
 445                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 446
 447                 v, err := ToInt16E(test.input)
 448                 if test.iserr {
 449                         assert.Error(t, err, errmsg)
 450                         continue
 451                 }
 452
 453                 assert.NoError(t, err, errmsg)
 454                 assert.Equal(t, test.expect, v, errmsg)
 455
 456                 // Non-E test
 457                 v = ToInt16(test.input)
 458                 assert.Equal(t, test.expect, v, errmsg)
 459         }
 460 }
 461
 462 func TestToInt8E(t *testing.T) {
 463         tests := []struct {
 464                 input  interface{}
 465                 expect int8
 466                 iserr  bool
 467         }{
 468                 {int(8), 8, false},
 469                 {int8(8), 8, false},
 470                 {int16(8), 8, false},
 471                 {int32(8), 8, false},
 472                 {int64(8), 8, false},
 473                 {uint(8), 8, false},
 474                 {uint8(8), 8, false},
 475                 {uint16(8), 8, false},
 476                 {uint32(8), 8, false},
 477                 {uint64(8), 8, false},
 478                 {float32(8.31), 8, false},
 479                 {float64(8.31), 8, false},
 480                 {true, 1, false},
 481                 {false, 0, false},
 482                 {"8", 8, false},
 483                 {nil, 0, false},
 484                 // errors
 485                 {"test", 0, true},
 486                 {testing.T{}, 0, true},
 487         }
 488
 489         for i, test := range tests {
 490                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 491
 492                 v, err := ToInt8E(test.input)
 493                 if test.iserr {
 494                         assert.Error(t, err, errmsg)
 495                         continue
 496                 }
 497
 498                 assert.NoError(t, err, errmsg)
 499                 assert.Equal(t, test.expect, v, errmsg)
 500
 501                 // Non-E test
 502                 v = ToInt8(test.input)
 503                 assert.Equal(t, test.expect, v, errmsg)
 504         }
 505 }
 506
 507 func TestToFloat64E(t *testing.T) {
 508         tests := []struct {
 509                 input  interface{}
 510                 expect float64
 511                 iserr  bool
 512         }{
 513                 {int(8), 8, false},
 514                 {int8(8), 8, false},
 515                 {int16(8), 8, false},
 516                 {int32(8), 8, false},
 517                 {int64(8), 8, false},
 518                 {uint(8), 8, false},
 519                 {uint8(8), 8, false},
 520                 {uint16(8), 8, false},
 521                 {uint32(8), 8, false},
 522                 {uint64(8), 8, false},
 523                 {float32(8), 8, false},
 524                 {float64(8.31), 8.31, false},
 525                 {"8", 8, false},
 526                 {true, 1, false},
 527                 {false, 0, false},
 528                 // errors
 529                 {"test", 0, true},
 530                 {testing.T{}, 0, true},
 531         }
 532
 533         for i, test := range tests {
 534                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 535
 536                 v, err := ToFloat64E(test.input)
 537                 if test.iserr {
 538                         assert.Error(t, err, errmsg)
 539                         continue
 540                 }
 541
 542                 assert.NoError(t, err, errmsg)
 543                 assert.Equal(t, test.expect, v, errmsg)
 544
 545                 // Non-E test
 546                 v = ToFloat64(test.input)
 547                 assert.Equal(t, test.expect, v, errmsg)
 548         }
 549 }
 550
 551 func TestToFloat32E(t *testing.T) {
 552         tests := []struct {
 553                 input  interface{}
 554                 expect float32
 555                 iserr  bool
 556         }{
 557                 {int(8), 8, false},
 558                 {int8(8), 8, false},
 559                 {int16(8), 8, false},
 560                 {int32(8), 8, false},
 561                 {int64(8), 8, false},
 562                 {uint(8), 8, false},
 563                 {uint8(8), 8, false},
 564                 {uint16(8), 8, false},
 565                 {uint32(8), 8, false},
 566                 {uint64(8), 8, false},
 567                 {float32(8.31), 8.31, false},
 568                 {float64(8.31), 8.31, false},
 569                 {"8", 8, false},
 570                 {true, 1, false},
 571                 {false, 0, false},
 572                 // errors
 573                 {"test", 0, true},
 574                 {testing.T{}, 0, true},
 575         }
 576
 577         for i, test := range tests {
 578                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 579
 580                 v, err := ToFloat32E(test.input)
 581                 if test.iserr {
 582                         assert.Error(t, err, errmsg)
 583                         continue
 584                 }
 585
 586                 assert.NoError(t, err, errmsg)
 587                 assert.Equal(t, test.expect, v, errmsg)
 588
 589                 // Non-E test
 590                 v = ToFloat32(test.input)
 591                 assert.Equal(t, test.expect, v, errmsg)
 592         }
 593 }
 594
 595 func TestToStringE(t *testing.T) {
 596         type Key struct {
 597                 k string
 598         }
 599         key := &Key{"foo"}
 600
 601         tests := []struct {
 602                 input  interface{}
 603                 expect string
 604                 iserr  bool
 605         }{
 606                 {int(8), "8", false},
 607                 {int8(8), "8", false},
 608                 {int16(8), "8", false},
 609                 {int32(8), "8", false},
 610                 {int64(8), "8", false},
 611                 {uint(8), "8", false},
 612                 {uint8(8), "8", false},
 613                 {uint16(8), "8", false},
 614                 {uint32(8), "8", false},
 615                 {uint64(8), "8", false},
 616                 {float32(8.31), "8.31", false},
 617                 {float64(8.31), "8.31", false},
 618                 {true, "true", false},
 619                 {false, "false", false},
 620                 {nil, "", false},
 621                 {[]byte("one time"), "one time", false},
 622                 {"one more time", "one more time", false},
 623                 {template.HTML("one time"), "one time", false},
 624                 {template.URL("http://somehost.foo"), "http://somehost.foo", false},
 625                 {template.JS("(1+2)"), "(1+2)", false},
 626                 {template.CSS("a"), "a", false},
 627                 {template.HTMLAttr("a"), "a", false},
 628                 // errors
 629                 {testing.T{}, "", true},
 630                 {key, "", true},
 631         }
 632
 633         for i, test := range tests {
 634                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 635
 636                 v, err := ToStringE(test.input)
 637                 if test.iserr {
 638                         assert.Error(t, err, errmsg)
 639                         continue
 640                 }
 641
 642                 assert.NoError(t, err, errmsg)
 643                 assert.Equal(t, test.expect, v, errmsg)
 644
 645                 // Non-E test
 646                 v = ToString(test.input)
 647                 assert.Equal(t, test.expect, v, errmsg)
 648         }
 649 }
 650
 651 type foo struct {
 652         val string
 653 }
 654
 655 func (x foo) String() string {
 656         return x.val
 657 }
 658
 659 func TestStringerToString(t *testing.T) {
 660         var x foo
 661         x.val = "bar"
 662         assert.Equal(t, "bar", ToString(x))
 663 }
 664
 665 type fu struct {
 666         val string
 667 }
 668
 669 func (x fu) Error() string {
 670         return x.val
 671 }
 672
 673 func TestErrorToString(t *testing.T) {
 674         var x fu
 675         x.val = "bar"
 676         assert.Equal(t, "bar", ToString(x))
 677 }
 678
 679 func TestStringMapStringSliceE(t *testing.T) {
 680         // ToStringMapString inputs/outputs
 681         var stringMapString = map[string]string{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}
 682         var stringMapInterface = map[string]interface{}{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}
 683         var interfaceMapString = map[interface{}]string{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}
 684         var interfaceMapInterface = map[interface{}]interface{}{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}
 685
 686         // ToStringMapStringSlice inputs/outputs
 687         var stringMapStringSlice = map[string][]string{"key 1": {"value 1", "value 2", "value 3"}, "key 2": {"value 1", "value 2", "value 3"}, "key 3": {"value 1", "value 2", "value 3"}}
 688         var stringMapInterfaceSlice = map[string][]interface{}{"key 1": {"value 1", "value 2", "value 3"}, "key 2": {"value 1", "value 2", "value 3"}, "key 3": {"value 1", "value 2", "value 3"}}
 689         var stringMapInterfaceInterfaceSlice = map[string]interface{}{"key 1": []interface{}{"value 1", "value 2", "value 3"}, "key 2": []interface{}{"value 1", "value 2", "value 3"}, "key 3": []interface{}{"value 1", "value 2", "value 3"}}
 690         var stringMapStringSingleSliceFieldsResult = map[string][]string{"key 1": {"value", "1"}, "key 2": {"value", "2"}, "key 3": {"value", "3"}}
 691         var interfaceMapStringSlice = map[interface{}][]string{"key 1": {"value 1", "value 2", "value 3"}, "key 2": {"value 1", "value 2", "value 3"}, "key 3": {"value 1", "value 2", "value 3"}}
 692         var interfaceMapInterfaceSlice = map[interface{}][]interface{}{"key 1": {"value 1", "value 2", "value 3"}, "key 2": {"value 1", "value 2", "value 3"}, "key 3": {"value 1", "value 2", "value 3"}}
 693
 694         var stringMapStringSliceMultiple = map[string][]string{"key 1": {"value 1", "value 2", "value 3"}, "key 2": {"value 1", "value 2", "value 3"}, "key 3": {"value 1", "value 2", "value 3"}}
 695         var stringMapStringSliceSingle = map[string][]string{"key 1": {"value 1"}, "key 2": {"value 2"}, "key 3": {"value 3"}}
 696
 697         var stringMapInterface1 = map[string]interface{}{"key 1": []string{"value 1"}, "key 2": []string{"value 2"}}
 698         var stringMapInterfaceResult1 = map[string][]string{"key 1": {"value 1"}, "key 2": {"value 2"}}
 699
 700         type Key struct {
 701                 k string
 702         }
 703
 704         tests := []struct {
 705                 input  interface{}
 706                 expect map[string][]string
 707                 iserr  bool
 708         }{
 709                 {stringMapStringSlice, stringMapStringSlice, false},
 710                 {stringMapInterfaceSlice, stringMapStringSlice, false},
 711                 {stringMapInterfaceInterfaceSlice, stringMapStringSlice, false},
 712                 {stringMapStringSliceMultiple, stringMapStringSlice, false},
 713                 {stringMapStringSliceMultiple, stringMapStringSlice, false},
 714                 {stringMapString, stringMapStringSliceSingle, false},
 715                 {stringMapInterface, stringMapStringSliceSingle, false},
 716                 {stringMapInterface1, stringMapInterfaceResult1, false},
 717                 {interfaceMapStringSlice, stringMapStringSlice, false},
 718                 {interfaceMapInterfaceSlice, stringMapStringSlice, false},
 719                 {interfaceMapString, stringMapStringSingleSliceFieldsResult, false},
 720                 {interfaceMapInterface, stringMapStringSingleSliceFieldsResult, false},
 721                 // errors
 722                 {nil, nil, true},
 723                 {testing.T{}, nil, true},
 724                 {map[interface{}]interface{}{"foo": testing.T{}}, nil, true},
 725                 {map[interface{}]interface{}{Key{"foo"}: "bar"}, nil, true}, // ToStringE(Key{"foo"}) should fail
 726         }
 727
 728         for i, test := range tests {
 729                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 730
 731                 v, err := ToStringMapStringSliceE(test.input)
 732                 if test.iserr {
 733                         assert.Error(t, err, errmsg)
 734                         continue
 735                 }
 736
 737                 assert.NoError(t, err, errmsg)
 738                 assert.Equal(t, test.expect, v, errmsg)
 739
 740                 // Non-E test
 741                 v = ToStringMapStringSlice(test.input)
 742                 assert.Equal(t, test.expect, v, errmsg)
 743         }
 744 }
 745
 746 func TestToStringMapE(t *testing.T) {
 747         tests := []struct {
 748                 input  interface{}
 749                 expect map[string]interface{}
 750                 iserr  bool
 751         }{
 752                 {map[interface{}]interface{}{"tag": "tags", "group": "groups"}, map[string]interface{}{"tag": "tags", "group": "groups"}, false},
 753                 {map[string]interface{}{"tag": "tags", "group": "groups"}, map[string]interface{}{"tag": "tags", "group": "groups"}, false},
 754                 // errors
 755                 {nil, nil, true},
 756                 {testing.T{}, nil, true},
 757         }
 758
 759         for i, test := range tests {
 760                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 761
 762                 v, err := ToStringMapE(test.input)
 763                 if test.iserr {
 764                         assert.Error(t, err, errmsg)
 765                         continue
 766                 }
 767
 768                 assert.NoError(t, err, errmsg)
 769                 assert.Equal(t, test.expect, v, errmsg)
 770
 771                 // Non-E test
 772                 v = ToStringMap(test.input)
 773                 assert.Equal(t, test.expect, v, errmsg)
 774         }
 775 }
 776
 777 func TestToStringMapBoolE(t *testing.T) {
 778         tests := []struct {
 779                 input  interface{}
 780                 expect map[string]bool
 781                 iserr  bool
 782         }{
 783                 {map[interface{}]interface{}{"v1": true, "v2": false}, map[string]bool{"v1": true, "v2": false}, false},
 784                 {map[string]interface{}{"v1": true, "v2": false}, map[string]bool{"v1": true, "v2": false}, false},
 785                 {map[string]bool{"v1": true, "v2": false}, map[string]bool{"v1": true, "v2": false}, false},
 786                 // errors
 787                 {nil, nil, true},
 788                 {testing.T{}, nil, true},
 789         }
 790
 791         for i, test := range tests {
 792                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 793
 794                 v, err := ToStringMapBoolE(test.input)
 795                 if test.iserr {
 796                         assert.Error(t, err, errmsg)
 797                         continue
 798                 }
 799
 800                 assert.NoError(t, err, errmsg)
 801                 assert.Equal(t, test.expect, v, errmsg)
 802
 803                 // Non-E test
 804                 v = ToStringMapBool(test.input)
 805                 assert.Equal(t, test.expect, v, errmsg)
 806         }
 807 }
 808
 809 func TestToStringMapStringE(t *testing.T) {
 810         var stringMapString = map[string]string{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}
 811         var stringMapInterface = map[string]interface{}{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}
 812         var interfaceMapString = map[interface{}]string{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}
 813         var interfaceMapInterface = map[interface{}]interface{}{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}
 814
 815         tests := []struct {
 816                 input  interface{}
 817                 expect map[string]string
 818                 iserr  bool
 819         }{
 820                 {stringMapString, stringMapString, false},
 821                 {stringMapInterface, stringMapString, false},
 822                 {interfaceMapString, stringMapString, false},
 823                 {interfaceMapInterface, stringMapString, false},
 824                 // errors
 825                 {nil, nil, true},
 826                 {testing.T{}, nil, true},
 827         }
 828
 829         for i, test := range tests {
 830                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 831
 832                 v, err := ToStringMapStringE(test.input)
 833                 if test.iserr {
 834                         assert.Error(t, err, errmsg)
 835                         continue
 836                 }
 837
 838                 assert.NoError(t, err, errmsg)
 839                 assert.Equal(t, test.expect, v, errmsg)
 840
 841                 // Non-E test
 842                 v = ToStringMapString(test.input)
 843                 assert.Equal(t, test.expect, v, errmsg)
 844         }
 845 }
 846
 847 func TestToBoolSliceE(t *testing.T) {
 848         tests := []struct {
 849                 input  interface{}
 850                 expect []bool
 851                 iserr  bool
 852         }{
 853                 {[]bool{true, false, true}, []bool{true, false, true}, false},
 854                 {[]interface{}{true, false, true}, []bool{true, false, true}, false},
 855                 {[]int{1, 0, 1}, []bool{true, false, true}, false},
 856                 {[]string{"true", "false", "true"}, []bool{true, false, true}, false},
 857                 // errors
 858                 {nil, nil, true},
 859                 {testing.T{}, nil, true},
 860                 {[]string{"foo", "bar"}, nil, true},
 861         }
 862
 863         for i, test := range tests {
 864                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 865
 866                 v, err := ToBoolSliceE(test.input)
 867                 if test.iserr {
 868                         assert.Error(t, err, errmsg)
 869                         continue
 870                 }
 871
 872                 assert.NoError(t, err, errmsg)
 873                 assert.Equal(t, test.expect, v, errmsg)
 874
 875                 // Non-E test
 876                 v = ToBoolSlice(test.input)
 877                 assert.Equal(t, test.expect, v, errmsg)
 878         }
 879 }
 880
 881 func TestToIntSliceE(t *testing.T) {
 882         tests := []struct {
 883                 input  interface{}
 884                 expect []int
 885                 iserr  bool
 886         }{
 887                 {[]int{1, 3}, []int{1, 3}, false},
 888                 {[]interface{}{1.2, 3.2}, []int{1, 3}, false},
 889                 {[]string{"2", "3"}, []int{2, 3}, false},
 890                 {[2]string{"2", "3"}, []int{2, 3}, false},
 891                 // errors
 892                 {nil, nil, true},
 893                 {testing.T{}, nil, true},
 894                 {[]string{"foo", "bar"}, nil, true},
 895         }
 896
 897         for i, test := range tests {
 898                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 899
 900                 v, err := ToIntSliceE(test.input)
 901                 if test.iserr {
 902                         assert.Error(t, err, errmsg)
 903                         continue
 904                 }
 905
 906                 assert.NoError(t, err, errmsg)
 907                 assert.Equal(t, test.expect, v, errmsg)
 908
 909                 // Non-E test
 910                 v = ToIntSlice(test.input)
 911                 assert.Equal(t, test.expect, v, errmsg)
 912         }
 913 }
 914
 915 func TestToSliceE(t *testing.T) {
 916         tests := []struct {
 917                 input  interface{}
 918                 expect []interface{}
 919                 iserr  bool
 920         }{
 921                 {[]interface{}{1, 3}, []interface{}{1, 3}, false},
 922                 {[]map[string]interface{}{{"k1": 1}, {"k2": 2}}, []interface{}{map[string]interface{}{"k1": 1}, map[string]interface{}{"k2": 2}}, false},
 923                 // errors
 924                 {nil, nil, true},
 925                 {testing.T{}, nil, true},
 926         }
 927
 928         for i, test := range tests {
 929                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 930
 931                 v, err := ToSliceE(test.input)
 932                 if test.iserr {
 933                         assert.Error(t, err, errmsg)
 934                         continue
 935                 }
 936
 937                 assert.NoError(t, err, errmsg)
 938                 assert.Equal(t, test.expect, v, errmsg)
 939
 940                 // Non-E test
 941                 v = ToSlice(test.input)
 942                 assert.Equal(t, test.expect, v, errmsg)
 943         }
 944 }
 945
 946 func TestToStringSliceE(t *testing.T) {
 947         tests := []struct {
 948                 input  interface{}
 949                 expect []string
 950                 iserr  bool
 951         }{
 952                 {[]string{"a", "b"}, []string{"a", "b"}, false},
 953                 {[]interface{}{1, 3}, []string{"1", "3"}, false},
 954                 {interface{}(1), []string{"1"}, false},
 955                 // errors
 956                 {nil, nil, true},
 957                 {testing.T{}, nil, true},
 958         }
 959
 960         for i, test := range tests {
 961                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 962
 963                 v, err := ToStringSliceE(test.input)
 964                 if test.iserr {
 965                         assert.Error(t, err, errmsg)
 966                         continue
 967                 }
 968
 969                 assert.NoError(t, err, errmsg)
 970                 assert.Equal(t, test.expect, v, errmsg)
 971
 972                 // Non-E test
 973                 v = ToStringSlice(test.input)
 974                 assert.Equal(t, test.expect, v, errmsg)
 975         }
 976 }
 977
 978 func TestToDurationSliceE(t *testing.T) {
 979         tests := []struct {
 980                 input  interface{}
 981                 expect []time.Duration
 982                 iserr  bool
 983         }{
 984                 {[]string{"1s", "1m"}, []time.Duration{time.Second, time.Minute}, false},
 985                 {[]int{1, 2}, []time.Duration{1, 2}, false},
 986                 {[]interface{}{1, 3}, []time.Duration{1, 3}, false},
 987                 // errors
 988                 {nil, nil, true},
 989                 {testing.T{}, nil, true},
 990         }
 991
 992         for i, test := range tests {
 993                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
 994
 995                 v, err := ToDurationSliceE(test.input)
 996                 if test.iserr {
 997                         assert.Error(t, err, errmsg)
 998                         continue
 999                 }
1000
1001                 assert.NoError(t, err, errmsg)
1002                 assert.Equal(t, test.expect, v, errmsg)
1003
1004                 // Non-E test
1005                 v = ToDurationSlice(test.input)
1006                 assert.Equal(t, test.expect, v, errmsg)
1007         }
1008 }
1009
1010 func TestToBoolE(t *testing.T) {
1011         tests := []struct {
1012                 input  interface{}
1013                 expect bool
1014                 iserr  bool
1015         }{
1016                 {0, false, false},
1017                 {nil, false, false},
1018                 {"false", false, false},
1019                 {"FALSE", false, false},
1020                 {"False", false, false},
1021                 {"f", false, false},
1022                 {"F", false, false},
1023                 {false, false, false},
1024
1025                 {"true", true, false},
1026                 {"TRUE", true, false},
1027                 {"True", true, false},
1028                 {"t", true, false},
1029                 {"T", true, false},
1030                 {1, true, false},
1031                 {true, true, false},
1032                 {-1, true, false},
1033
1034                 // errors
1035                 {"test", false, true},
1036                 {testing.T{}, false, true},
1037         }
1038
1039         for i, test := range tests {
1040                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
1041
1042                 v, err := ToBoolE(test.input)
1043                 if test.iserr {
1044                         assert.Error(t, err, errmsg)
1045                         continue
1046                 }
1047
1048                 assert.NoError(t, err, errmsg)
1049                 assert.Equal(t, test.expect, v, errmsg)
1050
1051                 // Non-E test
1052                 v = ToBool(test.input)
1053                 assert.Equal(t, test.expect, v, errmsg)
1054         }
1055 }
1056
1057 func BenchmarkTooBool(b *testing.B) {
1058         for i := 0; i < b.N; i++ {
1059                 if !ToBool(true) {
1060                         b.Fatal("ToBool returned false")
1061                 }
1062         }
1063 }
1064
1065 func TestIndirectPointers(t *testing.T) {
1066         x := 13
1067         y := &x
1068         z := &y
1069
1070         assert.Equal(t, ToInt(y), 13)
1071         assert.Equal(t, ToInt(z), 13)
1072 }
1073
1074 func TestToTimeEE(t *testing.T) {
1075         tests := []struct {
1076                 input  interface{}
1077                 expect time.Time
1078                 iserr  bool
1079         }{
1080                 {"2009-11-10 23:00:00 +0000 UTC", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false},   // Time.String()
1081                 {"Tue Nov 10 23:00:00 2009", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false},        // ANSIC
1082                 {"Tue Nov 10 23:00:00 UTC 2009", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false},    // UnixDate
1083                 {"Tue Nov 10 23:00:00 +0000 2009", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false},  // RubyDate
1084                 {"10 Nov 09 23:00 UTC", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false},             // RFC822
1085                 {"10 Nov 09 23:00 +0000", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false},           // RFC822Z
1086                 {"Tuesday, 10-Nov-09 23:00:00 UTC", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false}, // RFC850
1087                 {"Tue, 10 Nov 2009 23:00:00 UTC", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false},   // RFC1123
1088                 {"Tue, 10 Nov 2009 23:00:00 +0000", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false}, // RFC1123Z
1089                 {"2009-11-10T23:00:00Z", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false},            // RFC3339
1090                 {"2009-11-10T23:00:00Z", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false},            // RFC3339Nano
1091                 {"11:00PM", time.Date(0, 1, 1, 23, 0, 0, 0, time.UTC), false},                              // Kitchen
1092                 {"Nov 10 23:00:00", time.Date(0, 11, 10, 23, 0, 0, 0, time.UTC), false},                    // Stamp
1093                 {"Nov 10 23:00:00.000", time.Date(0, 11, 10, 23, 0, 0, 0, time.UTC), false},                // StampMilli
1094                 {"Nov 10 23:00:00.000000", time.Date(0, 11, 10, 23, 0, 0, 0, time.UTC), false},             // StampMicro
1095                 {"Nov 10 23:00:00.000000000", time.Date(0, 11, 10, 23, 0, 0, 0, time.UTC), false},          // StampNano
1096                 {"2016-03-06 15:28:01-00:00", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false},        // RFC3339 without T
1097                 {"2016-03-06 15:28:01", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false},
1098                 {"2016-03-06 15:28:01 -0000", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false},
1099                 {"2016-03-06 15:28:01 -00:00", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false},
1100                 {"2006-01-02", time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC), false},
1101                 {"02 Jan 2006", time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC), false},
1102                 {1472574600, time.Date(2016, 8, 30, 16, 30, 0, 0, time.UTC), false},
1103                 {int(1482597504), time.Date(2016, 12, 24, 16, 38, 24, 0, time.UTC), false},
1104                 {int64(1234567890), time.Date(2009, 2, 13, 23, 31, 30, 0, time.UTC), false},
1105                 {int32(1234567890), time.Date(2009, 2, 13, 23, 31, 30, 0, time.UTC), false},
1106                 {uint(1482597504), time.Date(2016, 12, 24, 16, 38, 24, 0, time.UTC), false},
1107                 {uint64(1234567890), time.Date(2009, 2, 13, 23, 31, 30, 0, time.UTC), false},
1108                 {uint32(1234567890), time.Date(2009, 2, 13, 23, 31, 30, 0, time.UTC), false},
1109                 {time.Date(2009, 2, 13, 23, 31, 30, 0, time.UTC), time.Date(2009, 2, 13, 23, 31, 30, 0, time.UTC), false},
1110                 // errors
1111                 {"2006", time.Time{}, true},
1112                 {testing.T{}, time.Time{}, true},
1113         }
1114
1115         for i, test := range tests {
1116                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
1117
1118                 v, err := ToTimeE(test.input)
1119                 if test.iserr {
1120                         assert.Error(t, err, errmsg)
1121                         continue
1122                 }
1123
1124                 assert.NoError(t, err, errmsg)
1125                 assert.Equal(t, test.expect, v.UTC(), errmsg)
1126
1127                 // Non-E test
1128                 v = ToTime(test.input)
1129                 assert.Equal(t, test.expect, v.UTC(), errmsg)
1130         }
1131 }
1132
1133 func TestToDurationE(t *testing.T) {
1134         var td time.Duration = 5
1135
1136         tests := []struct {
1137                 input  interface{}
1138                 expect time.Duration
1139                 iserr  bool
1140         }{
1141                 {time.Duration(5), td, false},
1142                 {int(5), td, false},
1143                 {int64(5), td, false},
1144                 {int32(5), td, false},
1145                 {int16(5), td, false},
1146                 {int8(5), td, false},
1147                 {uint(5), td, false},
1148                 {uint64(5), td, false},
1149                 {uint32(5), td, false},
1150                 {uint16(5), td, false},
1151                 {uint8(5), td, false},
1152                 {float64(5), td, false},
1153                 {float32(5), td, false},
1154                 {string("5"), td, false},
1155                 {string("5ns"), td, false},
1156                 {string("5us"), time.Microsecond * td, false},
1157                 {string("5µs"), time.Microsecond * td, false},
1158                 {string("5ms"), time.Millisecond * td, false},
1159                 {string("5s"), time.Second * td, false},
1160                 {string("5m"), time.Minute * td, false},
1161                 {string("5h"), time.Hour * td, false},
1162                 // errors
1163                 {"test", 0, true},
1164                 {testing.T{}, 0, true},
1165         }
1166
1167         for i, test := range tests {
1168                 errmsg := fmt.Sprintf("i = %d", i) // assert helper message
1169
1170                 v, err := ToDurationE(test.input)
1171                 if test.iserr {
1172                         assert.Error(t, err, errmsg)
1173                         continue
1174                 }
1175
1176                 assert.NoError(t, err, errmsg)
1177                 assert.Equal(t, test.expect, v, errmsg)
1178
1179                 // Non-E test
1180                 v = ToDuration(test.input)
1181                 assert.Equal(t, test.expect, v, errmsg)
1182         }
1183 }