891 lines · 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-exception6//7//===----------------------------------------------------------------------===//8 9#include "llvm/BinaryFormat/MsgPackReader.h"10#include "llvm/BinaryFormat/MsgPack.h"11#include "gtest/gtest.h"12 13using namespace llvm;14using namespace llvm::msgpack;15 16struct MsgPackReader : testing::Test {17 std::string Buffer;18 Object Obj;19};20 21TEST_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 44TEST_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 53TEST_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 63TEST_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 73TEST_F(MsgPackReader, TestReadFixNegativeInt) {74 // Positive values will be written in a UInt form, so max FixNegativeInt is -175 //76 // FixNegativeInt form bitpattern starts with 111, so min FixNegativeInt77 // is 11100000 = -3278 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 89TEST_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 99TEST_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 109TEST_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 119TEST_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 129TEST_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 139TEST_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 149TEST_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 159TEST_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 169TEST_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 179TEST_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 189TEST_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 199TEST_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 209TEST_F(MsgPackReader, TestReadFixPositiveInt) {210 // FixPositiveInt form bitpattern starts with 0, so max FixPositiveInt211 // is 01111111 = 127212 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 223TEST_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 233TEST_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 243TEST_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 253TEST_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 263TEST_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 273TEST_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 283TEST_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 293TEST_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 303TEST_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 313TEST_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 323TEST_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 333TEST_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 343TEST_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 353TEST_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 363TEST_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 373TEST_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 384TEST_F(MsgPackReader, TestReadFixStrMax) {385 // FixStr format's size is a 5 bit unsigned integer, so max is 11111 = 31386 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 396TEST_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 406TEST_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 417TEST_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 428TEST_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 438TEST_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 449TEST_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 460TEST_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 470TEST_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 481TEST_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 492TEST_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 502TEST_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 513TEST_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 524TEST_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 534TEST_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 545TEST_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 556TEST_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 566TEST_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 577TEST_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 588TEST_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 598TEST_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 608TEST_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 = 15616 EXPECT_EQ(Obj.Length, 15u);617}618 619TEST_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 629TEST_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 639TEST_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 649TEST_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 659TEST_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 669TEST_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 679TEST_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 689TEST_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 699TEST_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 = 15707 EXPECT_EQ(Obj.Length, 15u);708}709 710TEST_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 720TEST_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 730TEST_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 740TEST_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 750TEST_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 760TEST_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, 16771 772TEST_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 784TEST_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 796TEST_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 808TEST_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 820TEST_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 832TEST_F(MsgPackReader, TestReadExt8Min) {833 // There are fix variants for sizes 1 and 2834 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 844TEST_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 856TEST_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 868TEST_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 880TEST_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