decode_test.go (14994B)
1 package gojay 2 3 import ( 4 "bytes" 5 "fmt" 6 "reflect" 7 "testing" 8 9 "github.com/stretchr/testify/assert" 10 ) 11 12 type testDecodeObj struct { 13 test string 14 } 15 16 func (t *testDecodeObj) UnmarshalJSONObject(dec *Decoder, key string) error { 17 switch key { 18 case "test": 19 return dec.AddString(&t.test) 20 } 21 return nil 22 } 23 func (t *testDecodeObj) NKeys() int { 24 return 1 25 } 26 27 type testDecodeSlice []*testDecodeObj 28 29 func (t *testDecodeSlice) UnmarshalJSONArray(dec *Decoder) error { 30 obj := &testDecodeObj{} 31 if err := dec.AddObject(obj); err != nil { 32 return err 33 } 34 *t = append(*t, obj) 35 return nil 36 } 37 38 type allTypeDecodeTestCase struct { 39 name string 40 v interface{} 41 d []byte 42 expectations func(err error, v interface{}, t *testing.T) 43 } 44 45 func allTypesTestCases() []allTypeDecodeTestCase { 46 return []allTypeDecodeTestCase{ 47 { 48 v: new(string), 49 d: []byte(`"test string"`), 50 name: "test decode string", 51 expectations: func(err error, v interface{}, t *testing.T) { 52 vt := v.(*string) 53 assert.Nil(t, err, "err must be nil") 54 assert.Equal(t, "test string", *vt, "v must be equal to 1") 55 }, 56 }, 57 { 58 v: new(*string), 59 d: []byte(`"test string"`), 60 name: "test decode string", 61 expectations: func(err error, v interface{}, t *testing.T) { 62 vt := v.(**string) 63 assert.Nil(t, err, "err must be nil") 64 assert.Equal(t, "test string", **vt, "v must be equal to 1") 65 }, 66 }, 67 { 68 v: new(string), 69 d: []byte(`null`), 70 name: "test decode string null", 71 expectations: func(err error, v interface{}, t *testing.T) { 72 vt := v.(*string) 73 assert.Nil(t, err, "err must be nil") 74 assert.Equal(t, "", *vt, "v must be equal to 1") 75 }, 76 }, 77 { 78 v: new(*string), 79 d: []byte(`null`), 80 name: "test decode string null", 81 expectations: func(err error, v interface{}, t *testing.T) { 82 vt := v.(**string) 83 assert.Nil(t, err, "err must be nil") 84 assert.Nil(t, *vt, "v must be nil") 85 }, 86 }, 87 { 88 v: new(*string), 89 d: []byte(`1`), 90 name: "test decode string null", 91 expectations: func(err error, v interface{}, t *testing.T) { 92 vt := v.(**string) 93 assert.NotNil(t, err, "err must be nil") 94 assert.Nil(t, *vt, "v must be nil") 95 }, 96 }, 97 { 98 99 v: new(int), 100 d: []byte(`1`), 101 name: "test decode int", 102 expectations: func(err error, v interface{}, t *testing.T) { 103 vt := v.(*int) 104 assert.Nil(t, err, "err must be nil") 105 assert.Equal(t, 1, *vt, "v must be equal to 1") 106 }, 107 }, 108 { 109 v: new(*int), 110 d: []byte(`1`), 111 name: "test decode int", 112 expectations: func(err error, v interface{}, t *testing.T) { 113 vt := v.(**int) 114 assert.Nil(t, err, "err must be nil") 115 assert.Equal(t, 1, **vt, "v must be equal to 1") 116 }, 117 }, 118 { 119 v: new(*int), 120 d: []byte(`""`), 121 name: "test decode int", 122 expectations: func(err error, v interface{}, t *testing.T) { 123 assert.NotNil(t, err, "err must be nil") 124 }, 125 }, 126 { 127 v: new(*int8), 128 d: []byte(`1`), 129 name: "test decode int", 130 expectations: func(err error, v interface{}, t *testing.T) { 131 vt := v.(**int8) 132 assert.Nil(t, err, "err must be nil") 133 assert.Equal(t, int8(1), **vt, "v must be equal to 1") 134 }, 135 }, 136 { 137 v: new(*int8), 138 d: []byte(`""`), 139 name: "test decode int", 140 expectations: func(err error, v interface{}, t *testing.T) { 141 assert.NotNil(t, err, "err must be nil") 142 }, 143 }, 144 { 145 v: new(*int16), 146 d: []byte(`1`), 147 name: "test decode int", 148 expectations: func(err error, v interface{}, t *testing.T) { 149 vt := v.(**int16) 150 assert.Nil(t, err, "err must be nil") 151 assert.Equal(t, int16(1), **vt, "v must be equal to 1") 152 }, 153 }, 154 { 155 v: new(*int16), 156 d: []byte(`""`), 157 name: "test decode int", 158 expectations: func(err error, v interface{}, t *testing.T) { 159 assert.NotNil(t, err, "err must be nil") 160 }, 161 }, 162 { 163 v: new(int64), 164 d: []byte(`1`), 165 name: "test decode int64", 166 expectations: func(err error, v interface{}, t *testing.T) { 167 vt := v.(*int64) 168 assert.Nil(t, err, "err must be nil") 169 assert.Equal(t, int64(1), *vt, "v must be equal to 1") 170 }, 171 }, 172 { 173 v: new(*int64), 174 d: []byte(`1`), 175 name: "test decode int64", 176 expectations: func(err error, v interface{}, t *testing.T) { 177 vt := v.(**int64) 178 assert.Nil(t, err, "err must be nil") 179 assert.Equal(t, int64(1), **vt, "v must be equal to 1") 180 }, 181 }, 182 { 183 v: new(*int64), 184 d: []byte(`""`), 185 name: "test decode int64", 186 expectations: func(err error, v interface{}, t *testing.T) { 187 assert.NotNil(t, err, "err must be nil") 188 }, 189 }, 190 { 191 v: new(uint64), 192 d: []byte(`1`), 193 name: "test decode uint64", 194 expectations: func(err error, v interface{}, t *testing.T) { 195 vt := v.(*uint64) 196 assert.Nil(t, err, "err must be nil") 197 assert.Equal(t, uint64(1), *vt, "v must be equal to 1") 198 }, 199 }, 200 { 201 v: new(*uint64), 202 d: []byte(`1`), 203 name: "test decode uint64", 204 expectations: func(err error, v interface{}, t *testing.T) { 205 vt := v.(**uint64) 206 assert.Nil(t, err, "err must be nil") 207 assert.Equal(t, uint64(1), **vt, "v must be equal to 1") 208 }, 209 }, 210 { 211 v: new(interface{}), 212 d: []byte(`[{"test":"test"},{"test":"test2"}]`), 213 name: "test decode interface", 214 expectations: func(err error, v interface{}, t *testing.T) { 215 assert.Nil(t, err, "err must be nil") 216 // v is a pointer to an interface{}, we need to extract the content 217 vCont := reflect.ValueOf(v).Elem().Interface() 218 vt := vCont.([]interface{}) 219 assert.Len(t, vt, 2, "len of vt must be 2") 220 vt1 := vt[0].(map[string]interface{}) 221 assert.Equal(t, "test", vt1["test"], "vt1['test'] must be equal to 'test'") 222 vt2 := vt[1].(map[string]interface{}) 223 assert.Equal(t, "test2", vt2["test"], "vt2['test'] must be equal to 'test2'") 224 }, 225 }, 226 { 227 v: new(uint64), 228 d: []byte(`-1`), 229 name: "test decode uint64 negative", 230 expectations: func(err error, v interface{}, t *testing.T) { 231 vt := v.(*uint64) 232 assert.NotNil(t, err, "err must not be nil") 233 assert.Equal(t, uint64(0), *vt, "v must be equal to 1") 234 }, 235 }, 236 { 237 v: new(int32), 238 d: []byte(`1`), 239 name: "test decode int32", 240 expectations: func(err error, v interface{}, t *testing.T) { 241 vt := v.(*int32) 242 assert.Nil(t, err, "err must be nil") 243 assert.Equal(t, int32(1), *vt, "v must be equal to 1") 244 }, 245 }, 246 { 247 v: new(*int32), 248 d: []byte(`1`), 249 name: "test decode int32", 250 expectations: func(err error, v interface{}, t *testing.T) { 251 vt := v.(**int32) 252 assert.Nil(t, err, "err must be nil") 253 assert.Equal(t, int32(1), **vt, "v must be equal to 1") 254 }, 255 }, 256 { 257 v: new(uint32), 258 d: []byte(`1`), 259 name: "test decode uint32", 260 expectations: func(err error, v interface{}, t *testing.T) { 261 vt := v.(*uint32) 262 assert.Nil(t, err, "err must be nil") 263 assert.Equal(t, uint32(1), *vt, "v must be equal to 1") 264 }, 265 }, 266 { 267 v: new(*uint32), 268 d: []byte(`1`), 269 name: "test decode uint32", 270 expectations: func(err error, v interface{}, t *testing.T) { 271 vt := v.(**uint32) 272 assert.Nil(t, err, "err must be nil") 273 assert.Equal(t, uint32(1), **vt, "v must be equal to 1") 274 }, 275 }, 276 { 277 v: new(uint32), 278 d: []byte(`-1`), 279 name: "test decode uint32 negative", 280 expectations: func(err error, v interface{}, t *testing.T) { 281 vt := v.(*uint32) 282 assert.NotNil(t, err, "err must not be nil") 283 assert.Equal(t, uint32(0), *vt, "v must be equal to 1") 284 }, 285 }, 286 { 287 v: new(*uint16), 288 d: []byte(`1`), 289 name: "test decode uint16", 290 expectations: func(err error, v interface{}, t *testing.T) { 291 vt := v.(**uint16) 292 assert.Nil(t, err, "err must be nil") 293 assert.Equal(t, uint16(1), **vt, "v must be equal to 1") 294 }, 295 }, 296 { 297 v: new(*uint8), 298 d: []byte(`1`), 299 name: "test decode uint8", 300 expectations: func(err error, v interface{}, t *testing.T) { 301 vt := v.(**uint8) 302 assert.Nil(t, err, "err must be nil") 303 assert.Equal(t, uint8(1), **vt, "v must be equal to 1") 304 }, 305 }, 306 { 307 v: new(float64), 308 d: []byte(`1.15`), 309 name: "test decode float64", 310 expectations: func(err error, v interface{}, t *testing.T) { 311 vt := v.(*float64) 312 assert.Nil(t, err, "err must be nil") 313 assert.Equal(t, float64(1.15), *vt, "v must be equal to 1") 314 }, 315 }, 316 { 317 v: new(*float64), 318 d: []byte(`1.15`), 319 name: "test decode float64", 320 expectations: func(err error, v interface{}, t *testing.T) { 321 vt := v.(**float64) 322 assert.Nil(t, err, "err must be nil") 323 assert.Equal(t, float64(1.15), **vt, "v must be equal to 1") 324 }, 325 }, 326 { 327 v: new(float64), 328 d: []byte(`null`), 329 name: "test decode float64 null", 330 expectations: func(err error, v interface{}, t *testing.T) { 331 vt := v.(*float64) 332 assert.Nil(t, err, "err must be nil") 333 assert.Equal(t, float64(0), *vt, "v must be equal to 1") 334 }, 335 }, 336 { 337 v: new(*float32), 338 d: []byte(`1.15`), 339 name: "test decode float64 null", 340 expectations: func(err error, v interface{}, t *testing.T) { 341 vt := v.(**float32) 342 assert.Nil(t, err, "err must be nil") 343 assert.Equal(t, float32(1.15), **vt, "v must be equal to 1") 344 }, 345 }, 346 { 347 v: new(bool), 348 d: []byte(`true`), 349 name: "test decode bool true", 350 expectations: func(err error, v interface{}, t *testing.T) { 351 vt := v.(*bool) 352 assert.Nil(t, err, "err must be nil") 353 assert.Equal(t, true, *vt, "v must be equal to 1") 354 }, 355 }, 356 { 357 v: new(*bool), 358 d: []byte(`true`), 359 name: "test decode bool true", 360 expectations: func(err error, v interface{}, t *testing.T) { 361 vt := v.(**bool) 362 assert.Nil(t, err, "err must be nil") 363 assert.Equal(t, true, **vt, "v must be equal to 1") 364 }, 365 }, 366 { 367 v: new(bool), 368 d: []byte(`false`), 369 name: "test decode bool false", 370 expectations: func(err error, v interface{}, t *testing.T) { 371 vt := v.(*bool) 372 assert.Nil(t, err, "err must be nil") 373 assert.Equal(t, false, *vt, "v must be equal to 1") 374 }, 375 }, 376 { 377 v: new(bool), 378 d: []byte(`null`), 379 name: "test decode bool null", 380 expectations: func(err error, v interface{}, t *testing.T) { 381 vt := v.(*bool) 382 assert.Nil(t, err, "err must be nil") 383 assert.Equal(t, false, *vt, "v must be equal to 1") 384 }, 385 }, 386 { 387 v: new(testDecodeObj), 388 d: []byte(`{"test":"test"}`), 389 name: "test decode object", 390 expectations: func(err error, v interface{}, t *testing.T) { 391 vt := v.(*testDecodeObj) 392 assert.Nil(t, err, "err must be nil") 393 assert.Equal(t, "test", vt.test, "v.test must be equal to 'test'") 394 }, 395 }, 396 { 397 v: new(testDecodeObj), 398 d: []byte(`{"test":null}`), 399 name: "test decode object null key", 400 expectations: func(err error, v interface{}, t *testing.T) { 401 vt := v.(*testDecodeObj) 402 assert.Nil(t, err, "err must be nil") 403 assert.Equal(t, "", vt.test, "v.test must be equal to 'test'") 404 }, 405 }, 406 { 407 v: new(testDecodeObj), 408 d: []byte(`null`), 409 name: "test decode object null", 410 expectations: func(err error, v interface{}, t *testing.T) { 411 vt := v.(*testDecodeObj) 412 assert.Nil(t, err, "err must be nil") 413 assert.Equal(t, "", vt.test, "v.test must be equal to 'test'") 414 }, 415 }, 416 { 417 v: new(testDecodeSlice), 418 d: []byte(`[{"test":"test"}]`), 419 name: "test decode slice", 420 expectations: func(err error, v interface{}, t *testing.T) { 421 vtPtr := v.(*testDecodeSlice) 422 vt := *vtPtr 423 assert.Nil(t, err, "err must be nil") 424 assert.Len(t, vt, 1, "len of vt must be 1") 425 assert.Equal(t, "test", vt[0].test, "vt[0].test must be equal to 'test'") 426 }, 427 }, 428 { 429 v: new(testDecodeSlice), 430 d: []byte(`[{"test":"test"},{"test":"test2"}]`), 431 name: "test decode slice", 432 expectations: func(err error, v interface{}, t *testing.T) { 433 vtPtr := v.(*testDecodeSlice) 434 vt := *vtPtr 435 assert.Nil(t, err, "err must be nil") 436 assert.Len(t, vt, 2, "len of vt must be 2") 437 assert.Equal(t, "test", vt[0].test, "vt[0].test must be equal to 'test'") 438 assert.Equal(t, "test2", vt[1].test, "vt[1].test must be equal to 'test2'") 439 }, 440 }, 441 { 442 v: new(struct{}), 443 d: []byte(`{"test":"test"}`), 444 name: "test decode invalid type", 445 expectations: func(err error, v interface{}, t *testing.T) { 446 assert.NotNil(t, err, "err must not be nil") 447 assert.IsType(t, InvalidUnmarshalError(""), err, "err must be of type InvalidUnmarshalError") 448 assert.Equal(t, fmt.Sprintf(invalidUnmarshalErrorMsg, v), err.Error(), "err message should be equal to invalidUnmarshalErrorMsg") 449 }, 450 }, 451 } 452 } 453 454 // Unmarshal tests 455 func TestUnmarshalAllTypes(t *testing.T) { 456 for _, testCase := range allTypesTestCases() { 457 testCase := testCase 458 t.Run(testCase.name, func(*testing.T) { 459 err := Unmarshal(testCase.d, testCase.v) 460 testCase.expectations(err, testCase.v, t) 461 }) 462 } 463 } 464 465 // Decode tests 466 func TestDecodeAllTypes(t *testing.T) { 467 for _, testCase := range allTypesTestCases() { 468 testCase := testCase 469 t.Run(testCase.name, func(*testing.T) { 470 dec := NewDecoder(bytes.NewReader(testCase.d)) 471 err := dec.Decode(testCase.v) 472 testCase.expectations(err, testCase.v, t) 473 }) 474 } 475 } 476 477 func TestUnmarshalJSONObjects(t *testing.T) { 478 testCases := []struct { 479 name string 480 v UnmarshalerJSONObject 481 d []byte 482 expectations func(err error, v interface{}, t *testing.T) 483 }{ 484 { 485 v: new(testDecodeObj), 486 d: []byte(`{"test":"test"}`), 487 name: "test decode object", 488 expectations: func(err error, v interface{}, t *testing.T) { 489 vt := v.(*testDecodeObj) 490 assert.Nil(t, err, "err must be nil") 491 assert.Equal(t, "test", vt.test, "v.test must be equal to 'test'") 492 }, 493 }, 494 { 495 v: new(testDecodeObj), 496 d: []byte(`{"test":null}`), 497 name: "test decode object null key", 498 expectations: func(err error, v interface{}, t *testing.T) { 499 vt := v.(*testDecodeObj) 500 assert.Nil(t, err, "err must be nil") 501 assert.Equal(t, "", vt.test, "v.test must be equal to 'test'") 502 }, 503 }, 504 { 505 v: new(testDecodeObj), 506 d: []byte(`null`), 507 name: "test decode object null", 508 expectations: func(err error, v interface{}, t *testing.T) { 509 vt := v.(*testDecodeObj) 510 assert.Nil(t, err, "err must be nil") 511 assert.Equal(t, "", vt.test, "v.test must be equal to 'test'") 512 }, 513 }, 514 { 515 v: new(testDecodeObj), 516 d: []byte(`invalid json`), 517 name: "test decode object null", 518 expectations: func(err error, v interface{}, t *testing.T) { 519 assert.NotNil(t, err, "err must not be nil") 520 assert.IsType(t, InvalidJSONError(""), err, "err must be of type InvalidJSONError") 521 }, 522 }, 523 } 524 for _, testCase := range testCases { 525 testCase := testCase 526 t.Run(testCase.name, func(*testing.T) { 527 err := UnmarshalJSONObject(testCase.d, testCase.v) 528 testCase.expectations(err, testCase.v, t) 529 }) 530 } 531 }