1 //===- MsgPackReaderTest.cpp ------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/BinaryFormat/MsgPackReader.h" 11 #include "llvm/BinaryFormat/MsgPack.h" 12 #include "gtest/gtest.h" 13 14 using namespace llvm; 15 using namespace llvm::msgpack; 16 17 struct MsgPackReader : testing::Test { 18 std::string Buffer; 19 Object Obj; 20 }; 21 22 TEST_F(MsgPackReader, TestReadMultiple) { 23 Buffer = "\xc0\xc2"; 24 Reader MPReader(Buffer); 25 { 26 auto ContinueOrErr = MPReader.read(Obj); 27 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 28 EXPECT_TRUE(*ContinueOrErr); 29 EXPECT_EQ(Obj.Kind, Type::Nil); 30 } 31 { 32 auto ContinueOrErr = MPReader.read(Obj); 33 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 34 EXPECT_TRUE(*ContinueOrErr); 35 EXPECT_EQ(Obj.Kind, Type::Boolean); 36 EXPECT_EQ(Obj.Bool, false); 37 } 38 { 39 auto ContinueOrErr = MPReader.read(Obj); 40 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 41 EXPECT_FALSE(*ContinueOrErr); 42 } 43 } 44 45 TEST_F(MsgPackReader, TestReadNil) { 46 Buffer = "\xc0"; 47 Reader MPReader(Buffer); 48 auto ContinueOrErr = MPReader.read(Obj); 49 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 50 EXPECT_TRUE(*ContinueOrErr); 51 EXPECT_EQ(Obj.Kind, Type::Nil); 52 } 53 54 TEST_F(MsgPackReader, TestReadBoolFalse) { 55 Buffer = "\xc2"; 56 Reader MPReader(Buffer); 57 auto ContinueOrErr = MPReader.read(Obj); 58 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 59 EXPECT_TRUE(*ContinueOrErr); 60 EXPECT_EQ(Obj.Kind, Type::Boolean); 61 EXPECT_EQ(Obj.Bool, false); 62 } 63 64 TEST_F(MsgPackReader, TestReadBoolTrue) { 65 Buffer = "\xc3"; 66 Reader MPReader(Buffer); 67 auto ContinueOrErr = MPReader.read(Obj); 68 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 69 EXPECT_TRUE(*ContinueOrErr); 70 EXPECT_EQ(Obj.Kind, Type::Boolean); 71 EXPECT_EQ(Obj.Bool, true); 72 } 73 74 TEST_F(MsgPackReader, TestReadFixNegativeInt) { 75 // Positive values will be written in a UInt form, so max FixNegativeInt is -1 76 // 77 // FixNegativeInt form bitpattern starts with 111, so min FixNegativeInt 78 // is 11100000 = -32 79 for (int8_t i = -1; i >= -32; --i) { 80 Buffer.assign(1, static_cast<char>(i)); 81 Reader MPReader(Buffer); 82 auto ContinueOrErr = MPReader.read(Obj); 83 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 84 EXPECT_TRUE(*ContinueOrErr); 85 EXPECT_EQ(Obj.Kind, Type::Int); 86 EXPECT_EQ(Obj.Int, i); 87 } 88 } 89 90 TEST_F(MsgPackReader, TestReadInt8Max) { 91 Buffer = "\xd0\x7f"; 92 Reader MPReader(Buffer); 93 auto ContinueOrErr = MPReader.read(Obj); 94 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 95 EXPECT_TRUE(*ContinueOrErr); 96 EXPECT_EQ(Obj.Kind, Type::Int); 97 EXPECT_EQ(Obj.Int, INT8_MAX); 98 } 99 100 TEST_F(MsgPackReader, TestReadInt8Zero) { 101 Buffer.assign("\xd0\x00", 2); 102 Reader MPReader(Buffer); 103 auto ContinueOrErr = MPReader.read(Obj); 104 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 105 EXPECT_TRUE(*ContinueOrErr); 106 EXPECT_EQ(Obj.Kind, Type::Int); 107 EXPECT_EQ(Obj.Int, 0); 108 } 109 110 TEST_F(MsgPackReader, TestReadInt8Min) { 111 Buffer = "\xd0\x80"; 112 Reader MPReader(Buffer); 113 auto ContinueOrErr = MPReader.read(Obj); 114 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 115 EXPECT_TRUE(*ContinueOrErr); 116 EXPECT_EQ(Obj.Kind, Type::Int); 117 EXPECT_EQ(Obj.Int, INT8_MIN); 118 } 119 120 TEST_F(MsgPackReader, TestReadInt16Max) { 121 Buffer = "\xd1\x7f\xff"; 122 Reader MPReader(Buffer); 123 auto ContinueOrErr = MPReader.read(Obj); 124 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 125 EXPECT_TRUE(*ContinueOrErr); 126 EXPECT_EQ(Obj.Kind, Type::Int); 127 EXPECT_EQ(Obj.Int, INT16_MAX); 128 } 129 130 TEST_F(MsgPackReader, TestReadInt16Zero) { 131 Buffer.assign("\xd1\x00\x00", 3); 132 Reader MPReader(Buffer); 133 auto ContinueOrErr = MPReader.read(Obj); 134 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 135 EXPECT_TRUE(*ContinueOrErr); 136 EXPECT_EQ(Obj.Kind, Type::Int); 137 EXPECT_EQ(Obj.Int, 0); 138 } 139 140 TEST_F(MsgPackReader, TestReadInt16Min) { 141 Buffer.assign("\xd1\x80\x00", 3); 142 Reader MPReader(Buffer); 143 auto ContinueOrErr = MPReader.read(Obj); 144 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 145 EXPECT_TRUE(*ContinueOrErr); 146 EXPECT_EQ(Obj.Kind, Type::Int); 147 EXPECT_EQ(Obj.Int, INT16_MIN); 148 } 149 150 TEST_F(MsgPackReader, TestReadInt32Max) { 151 Buffer = "\xd2\x7f\xff\xff\xff"; 152 Reader MPReader(Buffer); 153 auto ContinueOrErr = MPReader.read(Obj); 154 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 155 EXPECT_TRUE(*ContinueOrErr); 156 EXPECT_EQ(Obj.Kind, Type::Int); 157 EXPECT_EQ(Obj.Int, INT32_MAX); 158 } 159 160 TEST_F(MsgPackReader, TestReadInt32Zero) { 161 Buffer.assign("\xd2\x00\x00\x00\x00", 5); 162 Reader MPReader(Buffer); 163 auto ContinueOrErr = MPReader.read(Obj); 164 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 165 EXPECT_TRUE(*ContinueOrErr); 166 EXPECT_EQ(Obj.Kind, Type::Int); 167 EXPECT_EQ(Obj.Int, 0); 168 } 169 170 TEST_F(MsgPackReader, TestReadInt32Min) { 171 Buffer.assign("\xd2\x80\x00\x00\x00", 5); 172 Reader MPReader(Buffer); 173 auto ContinueOrErr = MPReader.read(Obj); 174 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 175 EXPECT_TRUE(*ContinueOrErr); 176 EXPECT_EQ(Obj.Kind, Type::Int); 177 EXPECT_EQ(Obj.Int, INT32_MIN); 178 } 179 180 TEST_F(MsgPackReader, TestReadInt64Max) { 181 Buffer = "\xd3\x7f\xff\xff\xff\xff\xff\xff\xff"; 182 Reader MPReader(Buffer); 183 auto ContinueOrErr = MPReader.read(Obj); 184 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 185 EXPECT_TRUE(*ContinueOrErr); 186 EXPECT_EQ(Obj.Kind, Type::Int); 187 EXPECT_EQ(Obj.Int, INT64_MAX); 188 } 189 190 TEST_F(MsgPackReader, TestReadInt64Zero) { 191 Buffer.assign("\xd3\x00\x00\x00\x00\x00\x00\x00\x00", 9); 192 Reader MPReader(Buffer); 193 auto ContinueOrErr = MPReader.read(Obj); 194 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 195 EXPECT_TRUE(*ContinueOrErr); 196 EXPECT_EQ(Obj.Kind, Type::Int); 197 EXPECT_EQ(Obj.Int, 0); 198 } 199 200 TEST_F(MsgPackReader, TestReadInt64Min) { 201 Buffer.assign("\xd3\x80\x00\x00\x00\x00\x00\x00\x00", 9); 202 Reader MPReader(Buffer); 203 auto ContinueOrErr = MPReader.read(Obj); 204 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 205 EXPECT_TRUE(*ContinueOrErr); 206 EXPECT_EQ(Obj.Kind, Type::Int); 207 EXPECT_EQ(Obj.Int, INT64_MIN); 208 } 209 210 TEST_F(MsgPackReader, TestReadFixPositiveInt) { 211 // FixPositiveInt form bitpattern starts with 0, so max FixPositiveInt 212 // is 01111111 = 127 213 for (uint64_t u = 0; u <= 127; ++u) { 214 Buffer.assign(1, static_cast<char>(u)); 215 Reader MPReader(Buffer); 216 auto ContinueOrErr = MPReader.read(Obj); 217 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 218 EXPECT_TRUE(*ContinueOrErr); 219 EXPECT_EQ(Obj.Kind, Type::UInt); 220 EXPECT_EQ(Obj.UInt, u); 221 } 222 } 223 224 TEST_F(MsgPackReader, TestReadUInt8Zero) { 225 Buffer.assign("\xcc\x00", 2); 226 Reader MPReader(Buffer); 227 auto ContinueOrErr = MPReader.read(Obj); 228 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 229 EXPECT_TRUE(*ContinueOrErr); 230 EXPECT_EQ(Obj.Kind, Type::UInt); 231 EXPECT_EQ(Obj.UInt, 0u); 232 } 233 234 TEST_F(MsgPackReader, TestReadUInt8One) { 235 Buffer = "\xcc\x01"; 236 Reader MPReader(Buffer); 237 auto ContinueOrErr = MPReader.read(Obj); 238 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 239 EXPECT_TRUE(*ContinueOrErr); 240 EXPECT_EQ(Obj.Kind, Type::UInt); 241 EXPECT_EQ(Obj.UInt, 1u); 242 } 243 244 TEST_F(MsgPackReader, TestReadUInt8Max) { 245 Buffer = "\xcc\xff"; 246 Reader MPReader(Buffer); 247 auto ContinueOrErr = MPReader.read(Obj); 248 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 249 EXPECT_TRUE(*ContinueOrErr); 250 EXPECT_EQ(Obj.Kind, Type::UInt); 251 EXPECT_EQ(Obj.UInt, static_cast<uint8_t>(UINT8_MAX)); 252 } 253 254 TEST_F(MsgPackReader, TestReadUInt16Zero) { 255 Buffer.assign("\xcd\x00\x00", 3); 256 Reader MPReader(Buffer); 257 auto ContinueOrErr = MPReader.read(Obj); 258 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 259 EXPECT_TRUE(*ContinueOrErr); 260 EXPECT_EQ(Obj.Kind, Type::UInt); 261 EXPECT_EQ(Obj.UInt, 0u); 262 } 263 264 TEST_F(MsgPackReader, TestReadUInt16One) { 265 Buffer.assign("\xcd\x00\x01", 3); 266 Reader MPReader(Buffer); 267 auto ContinueOrErr = MPReader.read(Obj); 268 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 269 EXPECT_TRUE(*ContinueOrErr); 270 EXPECT_EQ(Obj.Kind, Type::UInt); 271 EXPECT_EQ(Obj.UInt, 1u); 272 } 273 274 TEST_F(MsgPackReader, TestReadUInt16Max) { 275 Buffer = "\xcd\xff\xff"; 276 Reader MPReader(Buffer); 277 auto ContinueOrErr = MPReader.read(Obj); 278 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 279 EXPECT_TRUE(*ContinueOrErr); 280 EXPECT_EQ(Obj.Kind, Type::UInt); 281 EXPECT_EQ(Obj.UInt, static_cast<uint16_t>(UINT16_MAX)); 282 } 283 284 TEST_F(MsgPackReader, TestReadUInt32Zero) { 285 Buffer.assign("\xce\x00\x00\x00\x00", 5); 286 Reader MPReader(Buffer); 287 auto ContinueOrErr = MPReader.read(Obj); 288 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 289 EXPECT_TRUE(*ContinueOrErr); 290 EXPECT_EQ(Obj.Kind, Type::UInt); 291 EXPECT_EQ(Obj.UInt, 0u); 292 } 293 294 TEST_F(MsgPackReader, TestReadUInt32One) { 295 Buffer.assign("\xce\x00\x00\x00\x01", 5); 296 Reader MPReader(Buffer); 297 auto ContinueOrErr = MPReader.read(Obj); 298 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 299 EXPECT_TRUE(*ContinueOrErr); 300 EXPECT_EQ(Obj.Kind, Type::UInt); 301 EXPECT_EQ(Obj.UInt, 1u); 302 } 303 304 TEST_F(MsgPackReader, TestReadUInt32Max) { 305 Buffer = "\xce\xff\xff\xff\xff"; 306 Reader MPReader(Buffer); 307 auto ContinueOrErr = MPReader.read(Obj); 308 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 309 EXPECT_TRUE(*ContinueOrErr); 310 EXPECT_EQ(Obj.Kind, Type::UInt); 311 EXPECT_EQ(Obj.UInt, static_cast<uint32_t>(UINT32_MAX)); 312 } 313 314 TEST_F(MsgPackReader, TestReadUInt64Zero) { 315 Buffer.assign("\xcf\x00\x00\x00\x00\x00\x00\x00\x00", 9); 316 Reader MPReader(Buffer); 317 auto ContinueOrErr = MPReader.read(Obj); 318 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 319 EXPECT_TRUE(*ContinueOrErr); 320 EXPECT_EQ(Obj.Kind, Type::UInt); 321 EXPECT_EQ(Obj.UInt, 0u); 322 } 323 324 TEST_F(MsgPackReader, TestReadUInt64One) { 325 Buffer.assign("\xcf\x00\x00\x00\x00\x00\x00\x00\x01", 9); 326 Reader MPReader(Buffer); 327 auto ContinueOrErr = MPReader.read(Obj); 328 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 329 EXPECT_TRUE(*ContinueOrErr); 330 EXPECT_EQ(Obj.Kind, Type::UInt); 331 EXPECT_EQ(Obj.UInt, 1u); 332 } 333 334 TEST_F(MsgPackReader, TestReadUInt64Max) { 335 Buffer = "\xcf\xff\xff\xff\xff\xff\xff\xff\xff"; 336 Reader MPReader(Buffer); 337 auto ContinueOrErr = MPReader.read(Obj); 338 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 339 EXPECT_TRUE(*ContinueOrErr); 340 EXPECT_EQ(Obj.Kind, Type::UInt); 341 EXPECT_EQ(Obj.UInt, static_cast<uint64_t>(UINT64_MAX)); 342 } 343 344 TEST_F(MsgPackReader, TestReadFloat32) { 345 Buffer = "\xca\xee\xee\xee\xef"; 346 Reader MPReader(Buffer); 347 auto ContinueOrErr = MPReader.read(Obj); 348 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 349 EXPECT_TRUE(*ContinueOrErr); 350 EXPECT_EQ(Obj.Kind, Type::Float); 351 EXPECT_EQ(Obj.Float, -3.6973142664068907e+28f); 352 } 353 354 TEST_F(MsgPackReader, TestReadFloat64) { 355 Buffer = "\xcb\xee\xee\xee\xee\xee\xee\xee\xef"; 356 Reader MPReader(Buffer); 357 auto ContinueOrErr = MPReader.read(Obj); 358 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 359 EXPECT_TRUE(*ContinueOrErr); 360 EXPECT_EQ(Obj.Kind, Type::Float); 361 EXPECT_EQ(Obj.Float, -2.2899894549927042e+226); 362 } 363 364 TEST_F(MsgPackReader, TestReadFixStrZero) { 365 Buffer = "\xa0"; 366 Reader MPReader(Buffer); 367 auto ContinueOrErr = MPReader.read(Obj); 368 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 369 EXPECT_TRUE(*ContinueOrErr); 370 EXPECT_EQ(Obj.Kind, Type::String); 371 EXPECT_EQ(Obj.Raw, StringRef()); 372 } 373 374 TEST_F(MsgPackReader, TestReadFixStrOne) { 375 std::string Result(1, 'a'); 376 Buffer = std::string("\xa1") + Result; 377 Reader MPReader(Buffer); 378 auto ContinueOrErr = MPReader.read(Obj); 379 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 380 EXPECT_TRUE(*ContinueOrErr); 381 EXPECT_EQ(Obj.Kind, Type::String); 382 EXPECT_EQ(Obj.Raw, Result); 383 } 384 385 TEST_F(MsgPackReader, TestReadFixStrMax) { 386 // FixStr format's size is a 5 bit unsigned integer, so max is 11111 = 31 387 std::string Result(31, 'a'); 388 Buffer = std::string("\xbf") + Result; 389 Reader MPReader(Buffer); 390 auto ContinueOrErr = MPReader.read(Obj); 391 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 392 EXPECT_TRUE(*ContinueOrErr); 393 EXPECT_EQ(Obj.Kind, Type::String); 394 EXPECT_EQ(Obj.Raw, Result); 395 } 396 397 TEST_F(MsgPackReader, TestReadStr8Zero) { 398 Buffer.assign("\xd9\x00", 2); 399 Reader MPReader(Buffer); 400 auto ContinueOrErr = MPReader.read(Obj); 401 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 402 EXPECT_TRUE(*ContinueOrErr); 403 EXPECT_EQ(Obj.Kind, Type::String); 404 EXPECT_EQ(Obj.Raw, StringRef()); 405 } 406 407 TEST_F(MsgPackReader, TestReadStr8One) { 408 std::string Result(1, 'a'); 409 Buffer = std::string("\xd9\x01") + Result; 410 Reader MPReader(Buffer); 411 auto ContinueOrErr = MPReader.read(Obj); 412 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 413 EXPECT_TRUE(*ContinueOrErr); 414 EXPECT_EQ(Obj.Kind, Type::String); 415 EXPECT_EQ(Obj.Raw, Result); 416 } 417 418 TEST_F(MsgPackReader, TestReadStr8Max) { 419 std::string Result(UINT8_MAX, 'a'); 420 Buffer = std::string("\xd9\xff") + Result; 421 Reader MPReader(Buffer); 422 auto ContinueOrErr = MPReader.read(Obj); 423 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 424 EXPECT_TRUE(*ContinueOrErr); 425 EXPECT_EQ(Obj.Kind, Type::String); 426 EXPECT_EQ(Obj.Raw, Result); 427 } 428 429 TEST_F(MsgPackReader, TestReadStr16Zero) { 430 Buffer.assign("\xda\x00\x00", 3); 431 Reader MPReader(Buffer); 432 auto ContinueOrErr = MPReader.read(Obj); 433 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 434 EXPECT_TRUE(*ContinueOrErr); 435 EXPECT_EQ(Obj.Kind, Type::String); 436 EXPECT_EQ(Obj.Raw, StringRef()); 437 } 438 439 TEST_F(MsgPackReader, TestReadStr16One) { 440 std::string Result(1, 'a'); 441 Buffer = std::string("\xda\x00\x01", 3) + Result; 442 Reader MPReader(Buffer); 443 auto ContinueOrErr = MPReader.read(Obj); 444 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 445 EXPECT_TRUE(*ContinueOrErr); 446 EXPECT_EQ(Obj.Kind, Type::String); 447 EXPECT_EQ(Obj.Raw, Result); 448 } 449 450 TEST_F(MsgPackReader, TestReadStr16Max) { 451 std::string Result(UINT16_MAX, 'a'); 452 Buffer = std::string("\xda\xff\xff") + Result; 453 Reader MPReader(Buffer); 454 auto ContinueOrErr = MPReader.read(Obj); 455 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 456 EXPECT_TRUE(*ContinueOrErr); 457 EXPECT_EQ(Obj.Kind, Type::String); 458 EXPECT_EQ(Obj.Raw, Result); 459 } 460 461 TEST_F(MsgPackReader, TestReadStr32Zero) { 462 Buffer.assign("\xdb\x00\x00\x00\x00", 5); 463 Reader MPReader(Buffer); 464 auto ContinueOrErr = MPReader.read(Obj); 465 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 466 EXPECT_TRUE(*ContinueOrErr); 467 EXPECT_EQ(Obj.Kind, Type::String); 468 EXPECT_EQ(Obj.Raw, StringRef()); 469 } 470 471 TEST_F(MsgPackReader, TestReadStr32One) { 472 std::string Result(1, 'a'); 473 Buffer = std::string("\xdb\x00\x00\x00\x01", 5) + Result; 474 Reader MPReader(Buffer); 475 auto ContinueOrErr = MPReader.read(Obj); 476 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 477 EXPECT_TRUE(*ContinueOrErr); 478 EXPECT_EQ(Obj.Kind, Type::String); 479 EXPECT_EQ(Obj.Raw, Result); 480 } 481 482 TEST_F(MsgPackReader, TestReadStr32Max) { 483 std::string Result(static_cast<uint32_t>(UINT16_MAX) + 1, 'a'); 484 Buffer = std::string("\xdb\x00\x01\x00\x00", 5) + Result; 485 Reader MPReader(Buffer); 486 auto ContinueOrErr = MPReader.read(Obj); 487 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 488 EXPECT_TRUE(*ContinueOrErr); 489 EXPECT_EQ(Obj.Kind, Type::String); 490 EXPECT_EQ(Obj.Raw, Result); 491 } 492 493 TEST_F(MsgPackReader, TestReadBin8Zero) { 494 Buffer.assign("\xc4\x00", 2); 495 Reader MPReader(Buffer); 496 auto ContinueOrErr = MPReader.read(Obj); 497 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 498 EXPECT_TRUE(*ContinueOrErr); 499 EXPECT_EQ(Obj.Kind, Type::Binary); 500 EXPECT_EQ(Obj.Raw, StringRef()); 501 } 502 503 TEST_F(MsgPackReader, TestReadBin8One) { 504 std::string Result(1, 'a'); 505 Buffer = std::string("\xc4\x01") + Result; 506 Reader MPReader(Buffer); 507 auto ContinueOrErr = MPReader.read(Obj); 508 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 509 EXPECT_TRUE(*ContinueOrErr); 510 EXPECT_EQ(Obj.Kind, Type::Binary); 511 EXPECT_EQ(Obj.Raw, Result); 512 } 513 514 TEST_F(MsgPackReader, TestReadBin8Max) { 515 std::string Result(UINT8_MAX, 'a'); 516 Buffer = std::string("\xc4\xff") + Result; 517 Reader MPReader(Buffer); 518 auto ContinueOrErr = MPReader.read(Obj); 519 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 520 EXPECT_TRUE(*ContinueOrErr); 521 EXPECT_EQ(Obj.Kind, Type::Binary); 522 EXPECT_EQ(Obj.Raw, Result); 523 } 524 525 TEST_F(MsgPackReader, TestReadBin16Zero) { 526 Buffer.assign("\xc5\x00\x00", 3); 527 Reader MPReader(Buffer); 528 auto ContinueOrErr = MPReader.read(Obj); 529 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 530 EXPECT_TRUE(*ContinueOrErr); 531 EXPECT_EQ(Obj.Kind, Type::Binary); 532 EXPECT_EQ(Obj.Raw, StringRef()); 533 } 534 535 TEST_F(MsgPackReader, TestReadBin16One) { 536 std::string Result(1, 'a'); 537 Buffer = std::string("\xc5\x00\x01", 3) + Result; 538 Reader MPReader(Buffer); 539 auto ContinueOrErr = MPReader.read(Obj); 540 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 541 EXPECT_TRUE(*ContinueOrErr); 542 EXPECT_EQ(Obj.Kind, Type::Binary); 543 EXPECT_EQ(Obj.Raw, Result); 544 } 545 546 TEST_F(MsgPackReader, TestReadBin16Max) { 547 std::string Result(UINT16_MAX, 'a'); 548 Buffer = std::string("\xc5\xff\xff") + Result; 549 Reader MPReader(Buffer); 550 auto ContinueOrErr = MPReader.read(Obj); 551 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 552 EXPECT_TRUE(*ContinueOrErr); 553 EXPECT_EQ(Obj.Kind, Type::Binary); 554 EXPECT_EQ(Obj.Raw, Result); 555 } 556 557 TEST_F(MsgPackReader, TestReadBin32Zero) { 558 Buffer.assign("\xc6\x00\x00\x00\x00", 5); 559 Reader MPReader(Buffer); 560 auto ContinueOrErr = MPReader.read(Obj); 561 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 562 EXPECT_TRUE(*ContinueOrErr); 563 EXPECT_EQ(Obj.Kind, Type::Binary); 564 EXPECT_EQ(Obj.Raw, StringRef()); 565 } 566 567 TEST_F(MsgPackReader, TestReadBin32One) { 568 std::string Result(1, 'a'); 569 Buffer = std::string("\xc6\x00\x00\x00\x01", 5) + Result; 570 Reader MPReader(Buffer); 571 auto ContinueOrErr = MPReader.read(Obj); 572 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 573 EXPECT_TRUE(*ContinueOrErr); 574 EXPECT_EQ(Obj.Kind, Type::Binary); 575 EXPECT_EQ(Obj.Raw, Result); 576 } 577 578 TEST_F(MsgPackReader, TestReadBin32Max) { 579 std::string Result(static_cast<uint32_t>(UINT16_MAX) + 1, 'a'); 580 Buffer = std::string("\xc6\x00\x01\x00\x00", 5) + Result; 581 Reader MPReader(Buffer); 582 auto ContinueOrErr = MPReader.read(Obj); 583 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 584 EXPECT_TRUE(*ContinueOrErr); 585 EXPECT_EQ(Obj.Kind, Type::Binary); 586 EXPECT_EQ(Obj.Raw, Result); 587 } 588 589 TEST_F(MsgPackReader, TestReadFixArrayZero) { 590 Buffer = "\x90"; 591 Reader MPReader(Buffer); 592 auto ContinueOrErr = MPReader.read(Obj); 593 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 594 EXPECT_TRUE(*ContinueOrErr); 595 EXPECT_EQ(Obj.Kind, Type::Array); 596 EXPECT_EQ(Obj.Length, 0u); 597 } 598 599 TEST_F(MsgPackReader, TestReadFixArrayOne) { 600 Buffer = "\x91"; 601 Reader MPReader(Buffer); 602 auto ContinueOrErr = MPReader.read(Obj); 603 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 604 EXPECT_TRUE(*ContinueOrErr); 605 EXPECT_EQ(Obj.Kind, Type::Array); 606 EXPECT_EQ(Obj.Length, 1u); 607 } 608 609 TEST_F(MsgPackReader, TestReadFixArrayMax) { 610 Buffer = "\x9f"; 611 Reader MPReader(Buffer); 612 auto ContinueOrErr = MPReader.read(Obj); 613 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 614 EXPECT_TRUE(*ContinueOrErr); 615 EXPECT_EQ(Obj.Kind, Type::Array); 616 // FixArray format's size is a 4 bit unsigned integer, so max is 1111 = 15 617 EXPECT_EQ(Obj.Length, 15u); 618 } 619 620 TEST_F(MsgPackReader, TestReadArray16Zero) { 621 Buffer.assign("\xdc\x00\x00", 3); 622 Reader MPReader(Buffer); 623 auto ContinueOrErr = MPReader.read(Obj); 624 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 625 EXPECT_TRUE(*ContinueOrErr); 626 EXPECT_EQ(Obj.Kind, Type::Array); 627 EXPECT_EQ(Obj.Length, 0u); 628 } 629 630 TEST_F(MsgPackReader, TestReadArray16One) { 631 Buffer.assign("\xdc\x00\x01", 3); 632 Reader MPReader(Buffer); 633 auto ContinueOrErr = MPReader.read(Obj); 634 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 635 EXPECT_TRUE(*ContinueOrErr); 636 EXPECT_EQ(Obj.Kind, Type::Array); 637 EXPECT_EQ(Obj.Length, 1u); 638 } 639 640 TEST_F(MsgPackReader, TestReadArray16Max) { 641 Buffer = "\xdc\xff\xff"; 642 Reader MPReader(Buffer); 643 auto ContinueOrErr = MPReader.read(Obj); 644 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 645 EXPECT_TRUE(*ContinueOrErr); 646 EXPECT_EQ(Obj.Kind, Type::Array); 647 EXPECT_EQ(Obj.Length, static_cast<uint16_t>(UINT16_MAX)); 648 } 649 650 TEST_F(MsgPackReader, TestReadArray32Zero) { 651 Buffer.assign("\xdd\x00\x00\x00\x00", 5); 652 Reader MPReader(Buffer); 653 auto ContinueOrErr = MPReader.read(Obj); 654 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 655 EXPECT_TRUE(*ContinueOrErr); 656 EXPECT_EQ(Obj.Kind, Type::Array); 657 EXPECT_EQ(Obj.Length, 0u); 658 } 659 660 TEST_F(MsgPackReader, TestReadArray32One) { 661 Buffer.assign("\xdd\x00\x00\x00\x01", 5); 662 Reader MPReader(Buffer); 663 auto ContinueOrErr = MPReader.read(Obj); 664 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 665 EXPECT_TRUE(*ContinueOrErr); 666 EXPECT_EQ(Obj.Kind, Type::Array); 667 EXPECT_EQ(Obj.Length, 1u); 668 } 669 670 TEST_F(MsgPackReader, TestReadArray32Max) { 671 Buffer = "\xdd\xff\xff\xff\xff"; 672 Reader MPReader(Buffer); 673 auto ContinueOrErr = MPReader.read(Obj); 674 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 675 EXPECT_TRUE(*ContinueOrErr); 676 EXPECT_EQ(Obj.Kind, Type::Array); 677 EXPECT_EQ(Obj.Length, static_cast<uint32_t>(UINT32_MAX)); 678 } 679 680 TEST_F(MsgPackReader, TestReadFixMapZero) { 681 Buffer = "\x80"; 682 Reader MPReader(Buffer); 683 auto ContinueOrErr = MPReader.read(Obj); 684 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 685 EXPECT_TRUE(*ContinueOrErr); 686 EXPECT_EQ(Obj.Kind, Type::Map); 687 EXPECT_EQ(Obj.Length, 0u); 688 } 689 690 TEST_F(MsgPackReader, TestReadFixMapOne) { 691 Buffer = "\x81"; 692 Reader MPReader(Buffer); 693 auto ContinueOrErr = MPReader.read(Obj); 694 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 695 EXPECT_TRUE(*ContinueOrErr); 696 EXPECT_EQ(Obj.Kind, Type::Map); 697 EXPECT_EQ(Obj.Length, 1u); 698 } 699 700 TEST_F(MsgPackReader, TestReadFixMapMax) { 701 Buffer = "\x8f"; 702 Reader MPReader(Buffer); 703 auto ContinueOrErr = MPReader.read(Obj); 704 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 705 EXPECT_TRUE(*ContinueOrErr); 706 EXPECT_EQ(Obj.Kind, Type::Map); 707 // FixMap format's size is a 4 bit unsigned integer, so max is 1111 = 15 708 EXPECT_EQ(Obj.Length, 15u); 709 } 710 711 TEST_F(MsgPackReader, TestReadMap16Zero) { 712 Buffer.assign("\xde\x00\x00", 3); 713 Reader MPReader(Buffer); 714 auto ContinueOrErr = MPReader.read(Obj); 715 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 716 EXPECT_TRUE(*ContinueOrErr); 717 EXPECT_EQ(Obj.Kind, Type::Map); 718 EXPECT_EQ(Obj.Length, 0u); 719 } 720 721 TEST_F(MsgPackReader, TestReadMap16One) { 722 Buffer.assign("\xde\x00\x01", 3); 723 Reader MPReader(Buffer); 724 auto ContinueOrErr = MPReader.read(Obj); 725 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 726 EXPECT_TRUE(*ContinueOrErr); 727 EXPECT_EQ(Obj.Kind, Type::Map); 728 EXPECT_EQ(Obj.Length, 1u); 729 } 730 731 TEST_F(MsgPackReader, TestReadMap16Max) { 732 Buffer = "\xde\xff\xff"; 733 Reader MPReader(Buffer); 734 auto ContinueOrErr = MPReader.read(Obj); 735 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 736 EXPECT_TRUE(*ContinueOrErr); 737 EXPECT_EQ(Obj.Kind, Type::Map); 738 EXPECT_EQ(Obj.Length, static_cast<uint16_t>(UINT16_MAX)); 739 } 740 741 TEST_F(MsgPackReader, TestReadMap32Zero) { 742 Buffer.assign("\xdf\x00\x00\x00\x00", 5); 743 Reader MPReader(Buffer); 744 auto ContinueOrErr = MPReader.read(Obj); 745 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 746 EXPECT_TRUE(*ContinueOrErr); 747 EXPECT_EQ(Obj.Kind, Type::Map); 748 EXPECT_EQ(Obj.Length, 0u); 749 } 750 751 TEST_F(MsgPackReader, TestReadMap32One) { 752 Buffer.assign("\xdf\x00\x00\x00\x01", 5); 753 Reader MPReader(Buffer); 754 auto ContinueOrErr = MPReader.read(Obj); 755 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 756 EXPECT_TRUE(*ContinueOrErr); 757 EXPECT_EQ(Obj.Kind, Type::Map); 758 EXPECT_EQ(Obj.Length, 1u); 759 } 760 761 TEST_F(MsgPackReader, TestReadMap32Max) { 762 Buffer = "\xdf\xff\xff\xff\xff"; 763 Reader MPReader(Buffer); 764 auto ContinueOrErr = MPReader.read(Obj); 765 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 766 EXPECT_TRUE(*ContinueOrErr); 767 EXPECT_EQ(Obj.Kind, Type::Map); 768 EXPECT_EQ(Obj.Length, static_cast<uint32_t>(UINT32_MAX)); 769 } 770 771 // FixExt formats are only available for these specific lengths: 1, 2, 4, 8, 16 772 773 TEST_F(MsgPackReader, TestReadFixExt1) { 774 std::string Result(1, 'a'); 775 Buffer = std::string("\xd4\x01") + Result; 776 Reader MPReader(Buffer); 777 auto ContinueOrErr = MPReader.read(Obj); 778 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 779 EXPECT_TRUE(*ContinueOrErr); 780 EXPECT_EQ(Obj.Kind, Type::Extension); 781 EXPECT_EQ(Obj.Extension.Type, 0x01); 782 EXPECT_EQ(Obj.Extension.Bytes, Result); 783 } 784 785 TEST_F(MsgPackReader, TestReadFixExt2) { 786 std::string Result(2, 'a'); 787 Buffer = std::string("\xd5\x01") + Result; 788 Reader MPReader(Buffer); 789 auto ContinueOrErr = MPReader.read(Obj); 790 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 791 EXPECT_TRUE(*ContinueOrErr); 792 EXPECT_EQ(Obj.Kind, Type::Extension); 793 EXPECT_EQ(Obj.Extension.Type, 0x01); 794 EXPECT_EQ(Obj.Extension.Bytes, Result); 795 } 796 797 TEST_F(MsgPackReader, TestReadFixExt4) { 798 std::string Result(4, 'a'); 799 Buffer = std::string("\xd6\x01") + Result; 800 Reader MPReader(Buffer); 801 auto ContinueOrErr = MPReader.read(Obj); 802 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 803 EXPECT_TRUE(*ContinueOrErr); 804 EXPECT_EQ(Obj.Kind, Type::Extension); 805 EXPECT_EQ(Obj.Extension.Type, 0x01); 806 EXPECT_EQ(Obj.Extension.Bytes, Result); 807 } 808 809 TEST_F(MsgPackReader, TestReadFixExt8) { 810 std::string Result(8, 'a'); 811 Buffer = std::string("\xd7\x01") + Result; 812 Reader MPReader(Buffer); 813 auto ContinueOrErr = MPReader.read(Obj); 814 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 815 EXPECT_TRUE(*ContinueOrErr); 816 EXPECT_EQ(Obj.Kind, Type::Extension); 817 EXPECT_EQ(Obj.Extension.Type, 0x01); 818 EXPECT_EQ(Obj.Extension.Bytes, Result); 819 } 820 821 TEST_F(MsgPackReader, TestReadFixExt16) { 822 std::string Result(16, 'a'); 823 Buffer = std::string("\xd8\x01") + Result; 824 Reader MPReader(Buffer); 825 auto ContinueOrErr = MPReader.read(Obj); 826 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 827 EXPECT_TRUE(*ContinueOrErr); 828 EXPECT_EQ(Obj.Kind, Type::Extension); 829 EXPECT_EQ(Obj.Extension.Type, 0x01); 830 EXPECT_EQ(Obj.Extension.Bytes, Result); 831 } 832 833 TEST_F(MsgPackReader, TestReadExt8Min) { 834 // There are fix variants for sizes 1 and 2 835 Buffer.assign("\xc7\x00\x01", 3); 836 Reader MPReader(Buffer); 837 auto ContinueOrErr = MPReader.read(Obj); 838 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 839 EXPECT_TRUE(*ContinueOrErr); 840 EXPECT_EQ(Obj.Kind, Type::Extension); 841 EXPECT_EQ(Obj.Extension.Type, 0x01); 842 EXPECT_EQ(Obj.Extension.Bytes, StringRef()); 843 } 844 845 TEST_F(MsgPackReader, TestReadExt8Max) { 846 std::string Result(UINT8_MAX, 'a'); 847 Buffer = std::string("\xc7\xff\x01", 3) + Result; 848 Reader MPReader(Buffer); 849 auto ContinueOrErr = MPReader.read(Obj); 850 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 851 EXPECT_TRUE(*ContinueOrErr); 852 EXPECT_EQ(Obj.Kind, Type::Extension); 853 EXPECT_EQ(Obj.Extension.Type, 0x01); 854 EXPECT_EQ(Obj.Extension.Bytes, Result); 855 } 856 857 TEST_F(MsgPackReader, TestReadExt16Min) { 858 std::string Result(static_cast<uint16_t>(UINT8_MAX) + 1, 'a'); 859 Buffer = std::string("\xc8\x01\x00\x01", 4) + Result; 860 Reader MPReader(Buffer); 861 auto ContinueOrErr = MPReader.read(Obj); 862 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 863 EXPECT_TRUE(*ContinueOrErr); 864 EXPECT_EQ(Obj.Kind, Type::Extension); 865 EXPECT_EQ(Obj.Extension.Type, 0x01); 866 EXPECT_EQ(Obj.Extension.Bytes, Result); 867 } 868 869 TEST_F(MsgPackReader, TestReadExt16Max) { 870 std::string Result(UINT16_MAX, 'a'); 871 Buffer = std::string("\xc8\xff\xff\x01") + Result; 872 Reader MPReader(Buffer); 873 auto ContinueOrErr = MPReader.read(Obj); 874 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 875 EXPECT_TRUE(*ContinueOrErr); 876 EXPECT_EQ(Obj.Kind, Type::Extension); 877 EXPECT_EQ(Obj.Extension.Type, 0x01); 878 EXPECT_EQ(Obj.Extension.Bytes, Result); 879 } 880 881 TEST_F(MsgPackReader, TestReadExt32Min) { 882 std::string Result(static_cast<uint32_t>(UINT16_MAX) + 1, 'a'); 883 Buffer = std::string("\xc9\x00\x01\x00\x00\x01", 6) + Result; 884 Reader MPReader(Buffer); 885 auto ContinueOrErr = MPReader.read(Obj); 886 EXPECT_TRUE(static_cast<bool>(ContinueOrErr)); 887 EXPECT_TRUE(*ContinueOrErr); 888 EXPECT_EQ(Obj.Kind, Type::Extension); 889 EXPECT_EQ(Obj.Extension.Type, 0x01); 890 EXPECT_EQ(Obj.Extension.Bytes, Result); 891 } 892