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