1#include "msgpack.h" 2 3#include <math.h> 4#include <vector> 5#include <limits> 6 7#include <gtest/gtest.h> 8 9#if defined(_MSC_VER) 10#define msgpack_rand() ((double)rand() / RAND_MAX) 11#else // _MSC_VER 12#define msgpack_rand() drand48() 13#endif // _MSC_VER 14 15using namespace std; 16 17const unsigned int kLoop = 10000; 18const double kEPS = 1e-10; 19 20#define GEN_TEST_SIGNED(test_type, func_type) \ 21 do { \ 22 vector<test_type> v; \ 23 v.push_back(0); \ 24 v.push_back(1); \ 25 v.push_back(-1); \ 26 v.push_back(numeric_limits<test_type>::min()); \ 27 v.push_back(numeric_limits<test_type>::max()); \ 28 for (unsigned int i = 0; i < kLoop; i++) \ 29 v.push_back(rand()); \ 30 for (unsigned int i = 0; i < v.size() ; i++) { \ 31 test_type val = v[i]; \ 32 msgpack_sbuffer sbuf; \ 33 msgpack_sbuffer_init(&sbuf); \ 34 msgpack_packer pk; \ 35 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); \ 36 msgpack_pack_##func_type(&pk, val); \ 37 msgpack_zone z; \ 38 msgpack_zone_init(&z, 2048); \ 39 msgpack_object obj; \ 40 msgpack_unpack_return ret = \ 41 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); \ 42 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); \ 43 if (val < 0) { \ 44 EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, obj.type); \ 45 EXPECT_EQ(val, obj.via.i64); \ 46 } else { \ 47 EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); \ 48 EXPECT_EQ(static_cast<uint64_t>(val), obj.via.u64); \ 49 } \ 50 msgpack_zone_destroy(&z); \ 51 msgpack_sbuffer_destroy(&sbuf); \ 52 } \ 53 } while(0) 54 55#define GEN_TEST_UNSIGNED(test_type, func_type) \ 56 do { \ 57 vector<test_type> v; \ 58 v.push_back(0); \ 59 v.push_back(1); \ 60 v.push_back(2); \ 61 v.push_back(numeric_limits<test_type>::min()); \ 62 v.push_back(numeric_limits<test_type>::max()); \ 63 for (unsigned int i = 0; i < kLoop; i++) \ 64 v.push_back(rand()); \ 65 for (unsigned int i = 0; i < v.size() ; i++) { \ 66 test_type val = v[i]; \ 67 msgpack_sbuffer sbuf; \ 68 msgpack_sbuffer_init(&sbuf); \ 69 msgpack_packer pk; \ 70 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); \ 71 msgpack_pack_##func_type(&pk, val); \ 72 msgpack_zone z; \ 73 msgpack_zone_init(&z, 2048); \ 74 msgpack_object obj; \ 75 msgpack_unpack_return ret = \ 76 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); \ 77 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); \ 78 EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); \ 79 EXPECT_EQ(val, obj.via.u64); \ 80 msgpack_zone_destroy(&z); \ 81 msgpack_sbuffer_destroy(&sbuf); \ 82 } \ 83 } while(0) 84 85TEST(MSGPACKC, simple_buffer_char) 86{ 87#if defined(CHAR_MIN) 88#if CHAR_MIN < 0 89 GEN_TEST_SIGNED(char, char); 90#else 91 GEN_TEST_UNSIGNED(char, char); 92#endif 93#else 94#error CHAR_MIN is not defined 95#endif 96} 97 98TEST(MSGPACKC, simple_buffer_singed_char) 99{ 100 GEN_TEST_SIGNED(signed char, signed_char); 101} 102 103TEST(MSGPACKC, simple_buffer_short) 104{ 105 GEN_TEST_SIGNED(short, short); 106} 107 108TEST(MSGPACKC, simple_buffer_int) 109{ 110 GEN_TEST_SIGNED(int, int); 111} 112 113TEST(MSGPACKC, simple_buffer_long) 114{ 115 GEN_TEST_SIGNED(long, long); 116} 117 118TEST(MSGPACKC, simple_buffer_long_long) 119{ 120 GEN_TEST_SIGNED(long long, long_long); 121} 122 123TEST(MSGPACKC, simple_buffer_unsigned_char) 124{ 125 GEN_TEST_UNSIGNED(unsigned char, unsigned_char); 126} 127 128TEST(MSGPACKC, simple_buffer_unsigned_short) 129{ 130 GEN_TEST_UNSIGNED(unsigned short, unsigned_short); 131} 132 133TEST(MSGPACKC, simple_buffer_unsigned_int) 134{ 135 GEN_TEST_UNSIGNED(unsigned int, unsigned_int); 136} 137 138TEST(MSGPACKC, simple_buffer_unsigned_long) 139{ 140 GEN_TEST_UNSIGNED(unsigned long, unsigned_long); 141} 142 143TEST(MSGPACKC, simple_buffer_unsigned_long_long) 144{ 145 GEN_TEST_UNSIGNED(unsigned long long, unsigned_long_long); 146} 147 148TEST(MSGPACKC, simple_buffer_uint8) 149{ 150 GEN_TEST_UNSIGNED(uint8_t, uint8); 151} 152 153TEST(MSGPACKC, simple_buffer_uint16) 154{ 155 GEN_TEST_UNSIGNED(uint16_t, uint16); 156} 157 158TEST(MSGPACKC, simple_buffer_uint32) 159{ 160 GEN_TEST_UNSIGNED(uint32_t, uint32); 161} 162 163TEST(MSGPACKC, simple_buffer_uint64) 164{ 165 GEN_TEST_UNSIGNED(uint64_t, uint64); 166} 167 168TEST(MSGPACKC, simple_buffer_int8) 169{ 170 GEN_TEST_SIGNED(int8_t, int8); 171} 172 173TEST(MSGPACKC, simple_buffer_int16) 174{ 175 GEN_TEST_SIGNED(int16_t, int16); 176} 177 178TEST(MSGPACKC, simple_buffer_int32) 179{ 180 GEN_TEST_SIGNED(int32_t, int32); 181} 182 183TEST(MSGPACKC, simple_buffer_int64) 184{ 185 GEN_TEST_SIGNED(int64_t, int64); 186} 187 188TEST(MSGPACKC, simple_buffer_float) 189{ 190 vector<float> v; 191 v.push_back(0.0); 192 v.push_back(1.0); 193 v.push_back(-1.0); 194 v.push_back(numeric_limits<float>::min()); 195 v.push_back(numeric_limits<float>::max()); 196 v.push_back(nanf("tag")); 197 if (numeric_limits<float>::has_infinity) { 198 v.push_back(numeric_limits<float>::infinity()); 199 v.push_back(-numeric_limits<float>::infinity()); 200 } 201 if (numeric_limits<float>::has_quiet_NaN) { 202 v.push_back(numeric_limits<float>::quiet_NaN()); 203 } 204 if (numeric_limits<float>::has_signaling_NaN) { 205 v.push_back(numeric_limits<float>::signaling_NaN()); 206 } 207 208 for (unsigned int i = 0; i < kLoop; i++) { 209 v.push_back(static_cast<float>(msgpack_rand())); 210 v.push_back(static_cast<float>(-msgpack_rand())); 211 } 212 213 for (unsigned int i = 0; i < v.size() ; i++) { 214 float val = v[i]; 215 msgpack_sbuffer sbuf; 216 msgpack_sbuffer_init(&sbuf); 217 msgpack_packer pk; 218 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 219 msgpack_pack_float(&pk, val); 220 msgpack_zone z; 221 msgpack_zone_init(&z, 2048); 222 msgpack_object obj; 223 msgpack_unpack_return ret = 224 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 225 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 226 EXPECT_EQ(MSGPACK_OBJECT_FLOAT, obj.type); 227#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) 228 EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, obj.type); 229#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT 230 if (isnan(val)) { 231 EXPECT_TRUE(isnan(obj.via.f64)); 232#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) 233 EXPECT_TRUE(isnan(obj.via.dec)); 234#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT 235 } 236 else if (isinf(val)) { 237 EXPECT_TRUE(isinf(obj.via.f64)); 238#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) 239 EXPECT_TRUE(isinf(obj.via.dec)); 240#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT 241 } 242 else { 243 EXPECT_TRUE(fabs(obj.via.f64 - val) <= kEPS); 244#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) 245 EXPECT_TRUE(fabs(obj.via.dec - val) <= kEPS); 246#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT 247 } 248 msgpack_zone_destroy(&z); 249 msgpack_sbuffer_destroy(&sbuf); 250 } 251} 252 253TEST(MSGPACKC, simple_buffer_double) 254{ 255 vector<double> v; 256 v.push_back(0.0); 257 v.push_back(-0.0); 258 v.push_back(1.0); 259 v.push_back(-1.0); 260 v.push_back(numeric_limits<double>::min()); 261 v.push_back(numeric_limits<double>::max()); 262 v.push_back(nan("tag")); 263 if (numeric_limits<double>::has_infinity) { 264 v.push_back(numeric_limits<double>::infinity()); 265 v.push_back(-numeric_limits<double>::infinity()); 266 } 267 if (numeric_limits<double>::has_quiet_NaN) { 268 v.push_back(numeric_limits<double>::quiet_NaN()); 269 } 270 if (numeric_limits<double>::has_signaling_NaN) { 271 v.push_back(numeric_limits<double>::signaling_NaN()); 272 } 273 for (unsigned int i = 0; i < kLoop; i++) { 274 v.push_back(msgpack_rand()); 275 v.push_back(-msgpack_rand()); 276 } 277 278 for (unsigned int i = 0; i < v.size() ; i++) { 279 double val = v[i]; 280 msgpack_sbuffer sbuf; 281 msgpack_sbuffer_init(&sbuf); 282 msgpack_packer pk; 283 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 284 msgpack_pack_double(&pk, val); 285 msgpack_zone z; 286 msgpack_zone_init(&z, 2048); 287 msgpack_object obj; 288 msgpack_unpack_return ret = 289 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 290 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 291 EXPECT_EQ(MSGPACK_OBJECT_FLOAT, obj.type); 292#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) 293 EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, obj.type); 294#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT 295 if (isnan(val)) { 296 EXPECT_TRUE(isnan(obj.via.f64)); 297#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) 298 EXPECT_TRUE(isnan(obj.via.dec)); 299#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT 300 } 301 else if (isinf(val)) { 302 EXPECT_TRUE(isinf(obj.via.f64)); 303#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) 304 EXPECT_TRUE(isinf(obj.via.dec)); 305#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT 306 } 307 else { 308 EXPECT_TRUE(fabs(obj.via.f64 - val) <= kEPS); 309#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) 310 EXPECT_TRUE(fabs(obj.via.dec - val) <= kEPS); 311#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT 312 } 313 msgpack_zone_destroy(&z); 314 msgpack_sbuffer_destroy(&sbuf); 315 } 316} 317 318TEST(MSGPACKC, simple_buffer_nil) 319{ 320 msgpack_sbuffer sbuf; 321 msgpack_sbuffer_init(&sbuf); 322 msgpack_packer pk; 323 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 324 msgpack_pack_nil(&pk); 325 msgpack_zone z; 326 msgpack_zone_init(&z, 2048); 327 msgpack_object obj; 328 msgpack_unpack_return ret = 329 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 330 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 331 EXPECT_EQ(MSGPACK_OBJECT_NIL, obj.type); 332 msgpack_zone_destroy(&z); 333 msgpack_sbuffer_destroy(&sbuf); 334} 335 336TEST(MSGPACKC, simple_buffer_true) 337{ 338 msgpack_sbuffer sbuf; 339 msgpack_sbuffer_init(&sbuf); 340 msgpack_packer pk; 341 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 342 msgpack_pack_true(&pk); 343 msgpack_zone z; 344 msgpack_zone_init(&z, 2048); 345 msgpack_object obj; 346 msgpack_unpack_return ret = 347 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 348 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 349 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, obj.type); 350 EXPECT_EQ(true, obj.via.boolean); 351 msgpack_zone_destroy(&z); 352 msgpack_sbuffer_destroy(&sbuf); 353} 354 355TEST(MSGPACKC, simple_buffer_false) 356{ 357 msgpack_sbuffer sbuf; 358 msgpack_sbuffer_init(&sbuf); 359 msgpack_packer pk; 360 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 361 msgpack_pack_false(&pk); 362 msgpack_zone z; 363 msgpack_zone_init(&z, 2048); 364 msgpack_object obj; 365 msgpack_unpack_return ret = 366 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 367 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 368 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, obj.type); 369 EXPECT_EQ(false, obj.via.boolean); 370 msgpack_zone_destroy(&z); 371 msgpack_sbuffer_destroy(&sbuf); 372} 373 374TEST(MSGPACKC, simple_buffer_fixext1) 375{ 376 msgpack_sbuffer sbuf; 377 msgpack_sbuffer_init(&sbuf); 378 msgpack_packer pk; 379 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 380 char const buf[] = { 2 }; 381 382 msgpack_pack_ext(&pk, sizeof(buf), 1); 383 msgpack_pack_ext_body(&pk, buf, sizeof(buf)); 384 msgpack_zone z; 385 msgpack_zone_init(&z, 2048); 386 msgpack_object obj; 387 msgpack_unpack_return ret = 388 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 389 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 390 EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); 391 EXPECT_EQ(1u, obj.via.ext.size); 392 EXPECT_EQ(1, obj.via.ext.type); 393 EXPECT_EQ(2, obj.via.ext.ptr[0]); 394 msgpack_zone_destroy(&z); 395 msgpack_sbuffer_destroy(&sbuf); 396} 397 398TEST(MSGPACKC, simple_buffer_fixext2) 399{ 400 msgpack_sbuffer sbuf; 401 msgpack_sbuffer_init(&sbuf); 402 msgpack_packer pk; 403 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 404 char const buf[] = { 2, 3 }; 405 406 msgpack_pack_ext(&pk, sizeof(buf), 0); 407 msgpack_pack_ext_body(&pk, buf, sizeof(buf)); 408 msgpack_zone z; 409 msgpack_zone_init(&z, 2048); 410 msgpack_object obj; 411 msgpack_unpack_return ret = 412 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 413 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 414 EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); 415 EXPECT_EQ(2u, obj.via.ext.size); 416 EXPECT_EQ(0, obj.via.ext.type); 417 EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); 418 msgpack_zone_destroy(&z); 419 msgpack_sbuffer_destroy(&sbuf); 420} 421 422TEST(MSGPACKC, simple_buffer_fixext4) 423{ 424 msgpack_sbuffer sbuf; 425 msgpack_sbuffer_init(&sbuf); 426 msgpack_packer pk; 427 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 428 char const buf[] = { 2, 3, 4, 5 }; 429 430 msgpack_pack_ext(&pk, sizeof(buf), 1); 431 msgpack_pack_ext_body(&pk, buf, sizeof(buf)); 432 msgpack_zone z; 433 msgpack_zone_init(&z, 2048); 434 msgpack_object obj; 435 msgpack_unpack_return ret = 436 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 437 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 438 EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); 439 EXPECT_EQ(4u, obj.via.ext.size); 440 EXPECT_EQ(1, obj.via.ext.type); 441 EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); 442 msgpack_zone_destroy(&z); 443 msgpack_sbuffer_destroy(&sbuf); 444} 445 446TEST(MSGPACKC, simple_buffer_fixext8) 447{ 448 msgpack_sbuffer sbuf; 449 msgpack_sbuffer_init(&sbuf); 450 msgpack_packer pk; 451 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 452 char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 }; 453 454 msgpack_pack_ext(&pk, sizeof(buf), 1); 455 msgpack_pack_ext_body(&pk, buf, sizeof(buf)); 456 msgpack_zone z; 457 msgpack_zone_init(&z, 2048); 458 msgpack_object obj; 459 msgpack_unpack_return ret = 460 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 461 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 462 EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); 463 EXPECT_EQ(8u, obj.via.ext.size); 464 EXPECT_EQ(1, obj.via.ext.type); 465 EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); 466 msgpack_zone_destroy(&z); 467 msgpack_sbuffer_destroy(&sbuf); 468} 469 470TEST(MSGPACKC, simple_buffer_fixext16) 471{ 472 msgpack_sbuffer sbuf; 473 msgpack_sbuffer_init(&sbuf); 474 msgpack_packer pk; 475 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 476 char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }; 477 478 msgpack_pack_ext(&pk, sizeof(buf), 1); 479 msgpack_pack_ext_body(&pk, buf, sizeof(buf)); 480 msgpack_zone z; 481 msgpack_zone_init(&z, 2048); 482 msgpack_object obj; 483 msgpack_unpack_return ret = 484 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 485 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 486 EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); 487 EXPECT_EQ(16u, obj.via.ext.size); 488 EXPECT_EQ(1, obj.via.ext.type); 489 EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); 490 msgpack_zone_destroy(&z); 491 msgpack_sbuffer_destroy(&sbuf); 492} 493 494TEST(MSGPACKC, simple_buffer_fixext_1byte_0) 495{ 496 const size_t size = 0; 497 msgpack_sbuffer sbuf; 498 msgpack_sbuffer_init(&sbuf); 499 msgpack_packer pk; 500 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 501 502 msgpack_pack_ext(&pk, size, 77); 503 // fprintf(stderr, "size: %u, data: \"", sbuf.size); 504 // for (size_t i = 0; i < sbuf.size; i++) 505 // fprintf(stderr, "%02x ", (uint8_t)sbuf.data[i]); 506 // fprintf(stderr, "\"\n"); 507 msgpack_zone z; 508 msgpack_zone_init(&z, 2048); 509 msgpack_object obj; 510 msgpack_unpack_return ret = 511 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 512 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 513 EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); 514 EXPECT_EQ(size, obj.via.ext.size); 515 EXPECT_EQ(77, obj.via.ext.type); 516 msgpack_zone_destroy(&z); 517 msgpack_sbuffer_destroy(&sbuf); 518} 519 520TEST(MSGPACKC, simple_buffer_fixext_1byte_255) 521{ 522 const size_t size = 255; 523 char buf[size]; 524 for (size_t i = 0; i != size; ++i) buf[i] = i; 525 526 msgpack_sbuffer sbuf; 527 msgpack_sbuffer_init(&sbuf); 528 msgpack_packer pk; 529 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 530 531 msgpack_pack_ext(&pk, size, 78); 532 msgpack_pack_ext_body(&pk, buf, sizeof(buf)); 533 msgpack_zone z; 534 msgpack_zone_init(&z, 2048); 535 msgpack_object obj; 536 msgpack_unpack_return ret = 537 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 538 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 539 EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); 540 EXPECT_EQ(size, obj.via.ext.size); 541 EXPECT_EQ(78, obj.via.ext.type); 542 EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); 543 msgpack_zone_destroy(&z); 544 msgpack_sbuffer_destroy(&sbuf); 545} 546 547TEST(MSGPACKC, simple_buffer_fixext_2byte_256) 548{ 549 const size_t size = 256; 550 char buf[size]; 551 for (size_t i = 0; i != size; ++i) buf[i] = i; 552 553 msgpack_sbuffer sbuf; 554 msgpack_sbuffer_init(&sbuf); 555 msgpack_packer pk; 556 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 557 558 msgpack_pack_ext(&pk, size, 79); 559 msgpack_pack_ext_body(&pk, buf, sizeof(buf)); 560 msgpack_zone z; 561 msgpack_zone_init(&z, 2048); 562 msgpack_object obj; 563 msgpack_unpack_return ret = 564 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 565 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 566 EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); 567 EXPECT_EQ(size, obj.via.ext.size); 568 EXPECT_EQ(79, obj.via.ext.type); 569 EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); 570 msgpack_zone_destroy(&z); 571 msgpack_sbuffer_destroy(&sbuf); 572} 573 574TEST(MSGPACKC, simple_buffer_fixext_2byte_65535) 575{ 576 const size_t size = 65535; 577 char buf[size]; 578 for (size_t i = 0; i != size; ++i) buf[i] = i; 579 580 msgpack_sbuffer sbuf; 581 msgpack_sbuffer_init(&sbuf); 582 msgpack_packer pk; 583 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 584 585 msgpack_pack_ext(&pk, size, 80); 586 msgpack_pack_ext_body(&pk, buf, sizeof(buf)); 587 msgpack_zone z; 588 msgpack_zone_init(&z, 2048); 589 msgpack_object obj; 590 msgpack_unpack_return ret = 591 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 592 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 593 EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); 594 EXPECT_EQ(size, obj.via.ext.size); 595 EXPECT_EQ(80, obj.via.ext.type); 596 EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); 597 msgpack_zone_destroy(&z); 598 msgpack_sbuffer_destroy(&sbuf); 599} 600 601TEST(MSGPACKC, simple_buffer_fixext_4byte_65536) 602{ 603 const size_t size = 65536; 604 char buf[size]; 605 for (size_t i = 0; i != size; ++i) buf[i] = i; 606 607 msgpack_sbuffer sbuf; 608 msgpack_sbuffer_init(&sbuf); 609 msgpack_packer pk; 610 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 611 612 msgpack_pack_ext(&pk, size, 81); 613 msgpack_pack_ext_body(&pk, buf, sizeof(buf)); 614 msgpack_zone z; 615 msgpack_zone_init(&z, 2048); 616 msgpack_object obj; 617 msgpack_unpack_return ret = 618 msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 619 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 620 EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); 621 EXPECT_EQ(size, obj.via.ext.size); 622 EXPECT_EQ(81, obj.via.ext.type); 623 EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); 624 msgpack_zone_destroy(&z); 625 msgpack_sbuffer_destroy(&sbuf); 626} 627 628TEST(MSGPACKC, simple_buffer_array) 629{ 630 unsigned int array_size = 5; 631 632 msgpack_sbuffer sbuf; 633 msgpack_sbuffer_init(&sbuf); 634 msgpack_packer pk; 635 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 636 msgpack_pack_array(&pk, array_size); 637 msgpack_pack_nil(&pk); 638 msgpack_pack_true(&pk); 639 msgpack_pack_false(&pk); 640 msgpack_pack_int(&pk, 10); 641 msgpack_pack_int(&pk, -10); 642 643 msgpack_zone z; 644 msgpack_zone_init(&z, 2048); 645 msgpack_object obj; 646 msgpack_unpack_return ret; 647 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 648 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 649 EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); 650 EXPECT_EQ(array_size, obj.via.array.size); 651 652 for (unsigned int i = 0; i < obj.via.array.size; i++) { 653 msgpack_object o = obj.via.array.ptr[i]; 654 switch (i) { 655 case 0: 656 EXPECT_EQ(MSGPACK_OBJECT_NIL, o.type); 657 break; 658 case 1: 659 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, o.type); 660 EXPECT_EQ(true, o.via.boolean); 661 break; 662 case 2: 663 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, o.type); 664 EXPECT_EQ(false, o.via.boolean); 665 break; 666 case 3: 667 EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, o.type); 668 EXPECT_EQ(10u, o.via.u64); 669 break; 670 case 4: 671 EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, o.type); 672 EXPECT_EQ(-10, o.via.i64); 673 break; 674 } 675 } 676 677 msgpack_zone_destroy(&z); 678 msgpack_sbuffer_destroy(&sbuf); 679} 680 681TEST(MSGPACKC, simple_buffer_map) 682{ 683 unsigned int map_size = 2; 684 685 msgpack_sbuffer sbuf; 686 msgpack_sbuffer_init(&sbuf); 687 msgpack_packer pk; 688 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 689 msgpack_pack_map(&pk, map_size); 690 msgpack_pack_true(&pk); 691 msgpack_pack_false(&pk); 692 msgpack_pack_int(&pk, 10); 693 msgpack_pack_int(&pk, -10); 694 695 msgpack_zone z; 696 msgpack_zone_init(&z, 2048); 697 msgpack_object obj; 698 msgpack_unpack_return ret; 699 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 700 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 701 EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); 702 EXPECT_EQ(map_size, obj.via.map.size); 703 704 for (unsigned int i = 0; i < map_size; i++) { 705 msgpack_object key = obj.via.map.ptr[i].key; 706 msgpack_object val = obj.via.map.ptr[i].val; 707 switch (i) { 708 case 0: 709 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, key.type); 710 EXPECT_EQ(true, key.via.boolean); 711 EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, val.type); 712 EXPECT_EQ(false, val.via.boolean); 713 break; 714 case 1: 715 EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, key.type); 716 EXPECT_EQ(10u, key.via.u64); 717 EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, val.type); 718 EXPECT_EQ(-10, val.via.i64); 719 break; 720 } 721 } 722 723 msgpack_zone_destroy(&z); 724 msgpack_sbuffer_destroy(&sbuf); 725} 726 727TEST(MSGPACKC, simple_buffer_str) 728{ 729 unsigned int str_size = 7; 730 731 msgpack_sbuffer sbuf; 732 msgpack_sbuffer_init(&sbuf); 733 msgpack_packer pk; 734 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 735 msgpack_pack_str(&pk, str_size); 736 msgpack_pack_str_body(&pk, "fr", 2); 737 msgpack_pack_str_body(&pk, "syuki", 5); 738 // invalid data 739 msgpack_pack_str_body(&pk, "", 0); 740 msgpack_pack_str_body(&pk, "kzk", 0); 741 742 msgpack_zone z; 743 msgpack_zone_init(&z, 2048); 744 msgpack_object obj; 745 msgpack_unpack_return ret; 746 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 747 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 748 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 749 EXPECT_EQ(str_size, obj.via.str.size); 750 EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); 751 752 msgpack_zone_destroy(&z); 753 msgpack_sbuffer_destroy(&sbuf); 754} 755 756TEST(MSGPACKC, simple_buffer_str_fix_l) 757{ 758 char const* str = NULL; 759 unsigned int str_size = 0; 760 msgpack_sbuffer sbuf; 761 msgpack_sbuffer_init(&sbuf); 762 msgpack_packer pk; 763 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 764 msgpack_pack_str(&pk, str_size); 765 msgpack_pack_str_body(&pk, str, str_size); 766 EXPECT_EQ(sbuf.size, 0x01u); 767 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xa0u)); 768 769 msgpack_zone z; 770 msgpack_zone_init(&z, 2048); 771 msgpack_object obj; 772 msgpack_unpack_return ret; 773 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 774 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 775 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 776 EXPECT_EQ(str_size, obj.via.str.size); 777 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 778 779 msgpack_zone_destroy(&z); 780 msgpack_sbuffer_destroy(&sbuf); 781} 782 783TEST(MSGPACKC, simple_buffer_str_fix_h) 784{ 785 char str[0x1f] = {'0'}; 786 unsigned int str_size = sizeof(str); 787 msgpack_sbuffer sbuf; 788 msgpack_sbuffer_init(&sbuf); 789 msgpack_packer pk; 790 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 791 msgpack_pack_str(&pk, str_size); 792 msgpack_pack_str_body(&pk, str, str_size); 793 EXPECT_EQ(sbuf.size, 0x1f+1u); 794 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xbfu)); 795 796 msgpack_zone z; 797 msgpack_zone_init(&z, 2048); 798 msgpack_object obj; 799 msgpack_unpack_return ret; 800 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 801 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 802 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 803 EXPECT_EQ(str_size, obj.via.str.size); 804 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 805 806 msgpack_zone_destroy(&z); 807 msgpack_sbuffer_destroy(&sbuf); 808} 809 810TEST(MSGPACKC, simple_buffer_str_8_l) 811{ 812 char str[0x1f+1] = {'0'}; 813 unsigned int str_size = sizeof(str); 814 msgpack_sbuffer sbuf; 815 msgpack_sbuffer_init(&sbuf); 816 msgpack_packer pk; 817 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 818 msgpack_pack_str(&pk, str_size); 819 msgpack_pack_str_body(&pk, str, str_size); 820 EXPECT_EQ(sbuf.size, 0x1f+1+2u); 821 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xd9u)); 822 EXPECT_EQ(sbuf.data[1], static_cast<char>(0x20u)); 823 824 msgpack_zone z; 825 msgpack_zone_init(&z, 2048); 826 msgpack_object obj; 827 msgpack_unpack_return ret; 828 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 829 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 830 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 831 EXPECT_EQ(str_size, obj.via.str.size); 832 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 833 834 msgpack_zone_destroy(&z); 835 msgpack_sbuffer_destroy(&sbuf); 836} 837 838TEST(MSGPACKC, simple_buffer_str_8_h) 839{ 840 char str[0xff] = {'0'}; 841 unsigned int str_size = sizeof(str); 842 msgpack_sbuffer sbuf; 843 msgpack_sbuffer_init(&sbuf); 844 msgpack_packer pk; 845 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 846 msgpack_pack_str(&pk, str_size); 847 msgpack_pack_str_body(&pk, str, str_size); 848 EXPECT_EQ(sbuf.size, 0xff+2u); 849 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xd9u)); 850 EXPECT_EQ(sbuf.data[1], static_cast<char>(0xffu)); 851 852 msgpack_zone z; 853 msgpack_zone_init(&z, 2048); 854 msgpack_object obj; 855 msgpack_unpack_return ret; 856 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 857 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 858 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 859 EXPECT_EQ(str_size, obj.via.str.size); 860 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 861 862 msgpack_zone_destroy(&z); 863 msgpack_sbuffer_destroy(&sbuf); 864} 865 866TEST(MSGPACKC, simple_buffer_str_16_l) 867{ 868 char str[0xff+1] = {'0'}; 869 unsigned int str_size = sizeof(str); 870 msgpack_sbuffer sbuf; 871 msgpack_sbuffer_init(&sbuf); 872 msgpack_packer pk; 873 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 874 msgpack_pack_str(&pk, str_size); 875 msgpack_pack_str_body(&pk, str, str_size); 876 EXPECT_EQ(sbuf.size, 0xff+1+3u); 877 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdau)); 878 EXPECT_EQ(sbuf.data[1], static_cast<char>(0x01u)); 879 EXPECT_EQ(sbuf.data[2], static_cast<char>(0x00u)); 880 881 msgpack_zone z; 882 msgpack_zone_init(&z, 2048); 883 msgpack_object obj; 884 msgpack_unpack_return ret; 885 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 886 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 887 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 888 EXPECT_EQ(str_size, obj.via.str.size); 889 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 890 891 msgpack_zone_destroy(&z); 892 msgpack_sbuffer_destroy(&sbuf); 893} 894 895TEST(MSGPACKC, simple_buffer_str_16_h) 896{ 897 char str[0xffff] = {'0'}; 898 unsigned int str_size = sizeof(str); 899 msgpack_sbuffer sbuf; 900 msgpack_sbuffer_init(&sbuf); 901 msgpack_packer pk; 902 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 903 msgpack_pack_str(&pk, str_size); 904 msgpack_pack_str_body(&pk, str, str_size); 905 EXPECT_EQ(sbuf.size, 0xffff+3u); 906 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdau)); 907 EXPECT_EQ(sbuf.data[1], static_cast<char>(0xffu)); 908 EXPECT_EQ(sbuf.data[2], static_cast<char>(0xffu)); 909 910 msgpack_zone z; 911 msgpack_zone_init(&z, 2048); 912 msgpack_object obj; 913 msgpack_unpack_return ret; 914 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 915 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 916 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 917 EXPECT_EQ(str_size, obj.via.str.size); 918 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 919 920 msgpack_zone_destroy(&z); 921 msgpack_sbuffer_destroy(&sbuf); 922} 923 924TEST(MSGPACKC, simple_buffer_str_32_l) 925{ 926 char str[0xffff+1] = {'0'}; 927 unsigned int str_size = sizeof(str); 928 msgpack_sbuffer sbuf; 929 msgpack_sbuffer_init(&sbuf); 930 msgpack_packer pk; 931 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 932 msgpack_pack_str(&pk, str_size); 933 msgpack_pack_str_body(&pk, str, str_size); 934 EXPECT_EQ(sbuf.size, 0xffff+1+5u); 935 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdbu)); 936 EXPECT_EQ(sbuf.data[1], static_cast<char>(0x00u)); 937 EXPECT_EQ(sbuf.data[2], static_cast<char>(0x01u)); 938 EXPECT_EQ(sbuf.data[3], static_cast<char>(0x00u)); 939 EXPECT_EQ(sbuf.data[4], static_cast<char>(0x00u)); 940 941 msgpack_zone z; 942 msgpack_zone_init(&z, 2048); 943 msgpack_object obj; 944 msgpack_unpack_return ret; 945 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 946 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 947 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 948 EXPECT_EQ(str_size, obj.via.str.size); 949 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 950 951 msgpack_zone_destroy(&z); 952 msgpack_sbuffer_destroy(&sbuf); 953} 954 955TEST(MSGPACKC, simple_buffer_v4raw_fix_l) 956{ 957 char const* str = NULL; 958 unsigned int str_size = 0; 959 msgpack_sbuffer sbuf; 960 msgpack_sbuffer_init(&sbuf); 961 msgpack_packer pk; 962 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 963 msgpack_pack_v4raw(&pk, str_size); 964 msgpack_pack_v4raw_body(&pk, str, str_size); 965 EXPECT_EQ(sbuf.size, 0x01u); 966 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xa0u)); 967 968 msgpack_zone z; 969 msgpack_zone_init(&z, 2048); 970 msgpack_object obj; 971 msgpack_unpack_return ret; 972 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 973 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 974 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 975 EXPECT_EQ(str_size, obj.via.str.size); 976 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 977 978 msgpack_zone_destroy(&z); 979 msgpack_sbuffer_destroy(&sbuf); 980} 981 982TEST(MSGPACKC, simple_buffer_v4raw_fix_h) 983{ 984 char str[0x1f] = {'0'}; 985 unsigned int str_size = sizeof(str); 986 msgpack_sbuffer sbuf; 987 msgpack_sbuffer_init(&sbuf); 988 msgpack_packer pk; 989 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 990 msgpack_pack_v4raw(&pk, str_size); 991 msgpack_pack_v4raw_body(&pk, str, str_size); 992 EXPECT_EQ(sbuf.size, 0x1f+1u); 993 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xbfu)); 994 995 msgpack_zone z; 996 msgpack_zone_init(&z, 2048); 997 msgpack_object obj; 998 msgpack_unpack_return ret; 999 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 1000 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1001 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 1002 EXPECT_EQ(str_size, obj.via.str.size); 1003 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 1004 1005 msgpack_zone_destroy(&z); 1006 msgpack_sbuffer_destroy(&sbuf); 1007} 1008 1009TEST(MSGPACKC, simple_buffer_v4raw_16_l) 1010{ 1011 char str[0x1f+1] = {'0'}; 1012 unsigned int str_size = sizeof(str); 1013 msgpack_sbuffer sbuf; 1014 msgpack_sbuffer_init(&sbuf); 1015 msgpack_packer pk; 1016 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 1017 msgpack_pack_v4raw(&pk, str_size); 1018 msgpack_pack_v4raw_body(&pk, str, str_size); 1019 EXPECT_EQ(sbuf.size, 0x1f+1+3u); 1020 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdau)); 1021 EXPECT_EQ(sbuf.data[1], static_cast<char>(0x00u)); 1022 EXPECT_EQ(sbuf.data[2], static_cast<char>(0x20u)); 1023 1024 msgpack_zone z; 1025 msgpack_zone_init(&z, 2048); 1026 msgpack_object obj; 1027 msgpack_unpack_return ret; 1028 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 1029 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1030 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 1031 EXPECT_EQ(str_size, obj.via.str.size); 1032 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 1033 1034 msgpack_zone_destroy(&z); 1035 msgpack_sbuffer_destroy(&sbuf); 1036} 1037 1038TEST(MSGPACKC, simple_buffer_v4raw_16_h) 1039{ 1040 char str[0xffff] = {'0'}; 1041 unsigned int str_size = sizeof(str); 1042 msgpack_sbuffer sbuf; 1043 msgpack_sbuffer_init(&sbuf); 1044 msgpack_packer pk; 1045 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 1046 msgpack_pack_v4raw(&pk, str_size); 1047 msgpack_pack_v4raw_body(&pk, str, str_size); 1048 EXPECT_EQ(sbuf.size, 0xffff+3u); 1049 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdau)); 1050 EXPECT_EQ(sbuf.data[1], static_cast<char>(0xffu)); 1051 EXPECT_EQ(sbuf.data[2], static_cast<char>(0xffu)); 1052 1053 msgpack_zone z; 1054 msgpack_zone_init(&z, 2048); 1055 msgpack_object obj; 1056 msgpack_unpack_return ret; 1057 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 1058 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1059 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 1060 EXPECT_EQ(str_size, obj.via.str.size); 1061 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 1062 1063 msgpack_zone_destroy(&z); 1064 msgpack_sbuffer_destroy(&sbuf); 1065} 1066 1067TEST(MSGPACKC, simple_buffer_v4raw_32_l) 1068{ 1069 char str[0xffff+1] = {'0'}; 1070 unsigned int str_size = sizeof(str); 1071 msgpack_sbuffer sbuf; 1072 msgpack_sbuffer_init(&sbuf); 1073 msgpack_packer pk; 1074 msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 1075 msgpack_pack_v4raw(&pk, str_size); 1076 msgpack_pack_v4raw_body(&pk, str, str_size); 1077 EXPECT_EQ(sbuf.size, 0xffff+1+5u); 1078 EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdbu)); 1079 EXPECT_EQ(sbuf.data[1], static_cast<char>(0x00u)); 1080 EXPECT_EQ(sbuf.data[2], static_cast<char>(0x01u)); 1081 EXPECT_EQ(sbuf.data[3], static_cast<char>(0x00u)); 1082 EXPECT_EQ(sbuf.data[4], static_cast<char>(0x00u)); 1083 1084 msgpack_zone z; 1085 msgpack_zone_init(&z, 2048); 1086 msgpack_object obj; 1087 msgpack_unpack_return ret; 1088 ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); 1089 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1090 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 1091 EXPECT_EQ(str_size, obj.via.str.size); 1092 EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size)); 1093 1094 msgpack_zone_destroy(&z); 1095 msgpack_sbuffer_destroy(&sbuf); 1096} 1097 1098 1099TEST(MSGPACKC, unpack_fixstr) 1100{ 1101 size_t str_size = 7; 1102 const char buf[] = { 1103 (char)0xa7, 'f', 'r', 's', 'y', 'u', 'k', 'i' 1104 }; 1105 1106 msgpack_zone z; 1107 msgpack_zone_init(&z, 2048); 1108 msgpack_object obj; 1109 msgpack_unpack_return ret; 1110 ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); 1111 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1112 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 1113 EXPECT_EQ(str_size, obj.via.str.size); 1114 EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); 1115 1116 msgpack_zone_destroy(&z); 1117} 1118 1119TEST(MSGPACKC, unpack_str8) 1120{ 1121 size_t str_size = 7; 1122 const char buf[] = { 1123 (char)0xd9, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' 1124 }; 1125 1126 msgpack_zone z; 1127 msgpack_zone_init(&z, 2048); 1128 msgpack_object obj; 1129 msgpack_unpack_return ret; 1130 ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); 1131 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1132 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 1133 EXPECT_EQ(str_size, obj.via.str.size); 1134 EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); 1135 1136 msgpack_zone_destroy(&z); 1137} 1138 1139TEST(MSGPACKC, unpack_str16) 1140{ 1141 size_t str_size = 7; 1142 const char buf[] = { 1143 (char)0xda, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' 1144 }; 1145 1146 msgpack_zone z; 1147 msgpack_zone_init(&z, 2048); 1148 msgpack_object obj; 1149 msgpack_unpack_return ret; 1150 ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); 1151 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1152 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 1153 EXPECT_EQ(str_size, obj.via.str.size); 1154 EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); 1155 1156 msgpack_zone_destroy(&z); 1157} 1158 1159TEST(MSGPACKC, unpack_str32) 1160{ 1161 size_t str_size = 7; 1162 const char buf[] = { 1163 (char)0xdb, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' 1164 }; 1165 1166 msgpack_zone z; 1167 msgpack_zone_init(&z, 2048); 1168 msgpack_object obj; 1169 msgpack_unpack_return ret; 1170 ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); 1171 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1172 EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); 1173 EXPECT_EQ(str_size, obj.via.str.size); 1174 EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); 1175 1176 msgpack_zone_destroy(&z); 1177} 1178 1179TEST(MSGPACKC, unpack_bin8) 1180{ 1181 size_t bin_size = 7; 1182 const char buf[] = { 1183 (char)0xc4, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' 1184 }; 1185 1186 msgpack_zone z; 1187 msgpack_zone_init(&z, 2048); 1188 msgpack_object obj; 1189 msgpack_unpack_return ret; 1190 ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); 1191 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1192 EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); 1193 EXPECT_EQ(bin_size, obj.via.bin.size); 1194 EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); 1195 1196 msgpack_zone_destroy(&z); 1197} 1198 1199TEST(MSGPACKC, unpack_bin16) 1200{ 1201 size_t bin_size = 7; 1202 const char buf[] = { 1203 (char)0xc5, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' 1204 }; 1205 1206 msgpack_zone z; 1207 msgpack_zone_init(&z, 2048); 1208 msgpack_object obj; 1209 msgpack_unpack_return ret; 1210 ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); 1211 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1212 EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); 1213 EXPECT_EQ(bin_size, obj.via.bin.size); 1214 EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); 1215 1216 msgpack_zone_destroy(&z); 1217} 1218 1219TEST(MSGPACKC, unpack_bin32) 1220{ 1221 size_t bin_size = 7; 1222 const char buf[] = { 1223 (char)0xc6, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' 1224 }; 1225 1226 msgpack_zone z; 1227 msgpack_zone_init(&z, 2048); 1228 msgpack_object obj; 1229 msgpack_unpack_return ret; 1230 ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); 1231 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1232 EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); 1233 EXPECT_EQ(bin_size, obj.via.bin.size); 1234 EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); 1235 1236 msgpack_zone_destroy(&z); 1237} 1238 1239TEST(MSGPACKC, unpack_array_uint64) 1240{ 1241 const char buf[] = { 1242 (char)0x91, (char)0xcf, (char)0xff, (char)0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 1243 }; 1244 msgpack_zone z; 1245 msgpack_zone_init(&z, 2048); 1246 msgpack_object obj; 1247 msgpack_unpack_return ret; 1248 ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); 1249 EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); 1250 EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); 1251 EXPECT_EQ(1u, obj.via.array.size); 1252 EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.via.array.ptr[0].type); 1253 EXPECT_EQ(0xFFF0000000000001LL, obj.via.array.ptr[0].via.u64); 1254 msgpack_zone_destroy(&z); 1255} 1256