llvm/unittests/BinaryFormat/MsgPackReaderTest.cpp

   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 }