523 lines · cpp
1//===- MsgPackWriterTest.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/MsgPackWriter.h"10#include "llvm/BinaryFormat/MsgPack.h"11#include "gtest/gtest.h"12 13using namespace llvm;14using namespace llvm::msgpack;15 16struct MsgPackWriter : testing::Test {17 std::string Buffer;18 llvm::raw_string_ostream OStream;19 Writer MPWriter;20 21 MsgPackWriter() : OStream(Buffer), MPWriter(OStream) {}22};23 24TEST_F(MsgPackWriter, TestWriteNil) {25 MPWriter.writeNil();26 EXPECT_EQ(OStream.str(), "\xc0");27}28 29TEST_F(MsgPackWriter, TestWriteBool) {30 MPWriter.write(true);31 MPWriter.write(false);32 EXPECT_EQ(OStream.str(), "\xc3\xc2");33}34 35TEST_F(MsgPackWriter, TestWriteFixPositiveInt) {36 // FixPositiveInt form bitpattern starts with 0, so max FixPositiveInt37 // is 01111111 = 12738 for (uint64_t u = 0; u <= 127; ++u) {39 Buffer.clear();40 MPWriter.write(u);41 std::string Output = OStream.str();42 EXPECT_EQ(Output.size(), 1u);43 EXPECT_EQ(Output[0], static_cast<uint8_t>(u));44 }45}46 47TEST_F(MsgPackWriter, TestWriteUInt8Min) {48 // See TestWriteFixPositiveInt for why 128 is the min non-fix Int849 uint64_t u = 128;50 MPWriter.write(u);51 EXPECT_EQ(OStream.str(), "\xcc\x80");52}53 54TEST_F(MsgPackWriter, TestWriteUInt8) {55 uint64_t u = 221;56 MPWriter.write(u);57 EXPECT_EQ(OStream.str(), "\xcc\xdd");58}59 60TEST_F(MsgPackWriter, TestWriteUInt8Max) {61 uint64_t u = UINT8_MAX;62 MPWriter.write(u);63 EXPECT_EQ(OStream.str(), "\xcc\xff");64}65 66TEST_F(MsgPackWriter, TestWriteUInt16Min) {67 uint64_t u = static_cast<uint64_t>(UINT8_MAX) + 1;68 MPWriter.write(u);69 EXPECT_EQ(OStream.str(), std::string("\xcd\x01\x00", 3));70}71 72TEST_F(MsgPackWriter, TestWriteUInt16) {73 uint64_t u = 43981;74 MPWriter.write(u);75 EXPECT_EQ(OStream.str(), "\xcd\xab\xcd");76}77 78TEST_F(MsgPackWriter, TestWriteUInt16Max) {79 uint64_t u = UINT16_MAX;80 MPWriter.write(u);81 EXPECT_EQ(OStream.str(), "\xcd\xff\xff");82}83 84TEST_F(MsgPackWriter, TestWriteUInt32Min) {85 uint64_t u = static_cast<uint64_t>(UINT16_MAX) + 1;86 MPWriter.write(u);87 EXPECT_EQ(OStream.str(), std::string("\xce\x00\x01\x00\x00", 5));88}89 90TEST_F(MsgPackWriter, TestWriteUInt32) {91 uint64_t u = 2882400186;92 MPWriter.write(u);93 EXPECT_EQ(OStream.str(), "\xce\xab\xcd\xef\xba");94}95 96TEST_F(MsgPackWriter, TestWriteUInt32Max) {97 uint64_t u = UINT32_MAX;98 MPWriter.write(u);99 EXPECT_EQ(OStream.str(), "\xce\xff\xff\xff\xff");100}101 102TEST_F(MsgPackWriter, TestWriteUInt64Min) {103 uint64_t u = static_cast<uint64_t>(UINT32_MAX) + 1;104 MPWriter.write(u);105 EXPECT_EQ(OStream.str(),106 std::string("\xcf\x00\x00\x00\x01\x00\x00\x00\x00", 9));107}108 109TEST_F(MsgPackWriter, TestWriteUInt64) {110 uint64_t u = 0x010203040506074a;111 MPWriter.write(u);112 EXPECT_EQ(OStream.str(), "\xcf\x01\x02\x03\x04\x05\x06\x07\x4a");113}114 115TEST_F(MsgPackWriter, TestWriteUInt64Max) {116 uint64_t u = UINT64_MAX;117 MPWriter.write(u);118 EXPECT_EQ(OStream.str(), "\xcf\xff\xff\xff\xff\xff\xff\xff\xff");119}120 121TEST_F(MsgPackWriter, TestWriteFixNegativeInt) {122 // Positive values will be written in a UInt form, so max FixNegativeInt is -1123 //124 // FixNegativeInt form bitpattern starts with 111, so min FixNegativeInt125 // is 11100000 = -32126 for (int64_t i = -1; i >= -32; --i) {127 Buffer.clear();128 MPWriter.write(i);129 std::string Output = OStream.str();130 EXPECT_EQ(Output.size(), 1u);131 EXPECT_EQ(static_cast<int8_t>(Output[0]), static_cast<int8_t>(i));132 }133}134 135TEST_F(MsgPackWriter, TestWriteInt8Max) {136 // See TestWriteFixNegativeInt for why -33 is the max non-fix Int8137 int64_t i = -33;138 MPWriter.write(i);139 EXPECT_EQ(OStream.str(), "\xd0\xdf");140}141 142TEST_F(MsgPackWriter, TestWriteInt8) {143 int64_t i = -40;144 MPWriter.write(i);145 EXPECT_EQ(OStream.str(), "\xd0\xd8");146}147 148TEST_F(MsgPackWriter, TestWriteInt8Min) {149 int64_t i = INT8_MIN;150 MPWriter.write(i);151 EXPECT_EQ(OStream.str(), "\xd0\x80");152}153 154TEST_F(MsgPackWriter, TestWriteInt16Max) {155 int64_t i = static_cast<int64_t>(INT8_MIN) - 1;156 MPWriter.write(i);157 EXPECT_EQ(OStream.str(), "\xd1\xff\x7f");158}159 160TEST_F(MsgPackWriter, TestWriteInt16) {161 int64_t i = -4369;162 MPWriter.write(i);163 EXPECT_EQ(OStream.str(), "\xd1\xee\xef");164}165 166TEST_F(MsgPackWriter, TestWriteInt16Min) {167 int64_t i = INT16_MIN;168 MPWriter.write(i);169 EXPECT_EQ(OStream.str(), std::string("\xd1\x80\x00", 3));170}171 172TEST_F(MsgPackWriter, TestWriteInt32Max) {173 int64_t i = static_cast<int64_t>(INT16_MIN) - 1;174 MPWriter.write(i);175 EXPECT_EQ(OStream.str(), "\xd2\xff\xff\x7f\xff");176}177 178TEST_F(MsgPackWriter, TestWriteInt32) {179 int64_t i = -286331153;180 MPWriter.write(i);181 EXPECT_EQ(OStream.str(), "\xd2\xee\xee\xee\xef");182}183 184TEST_F(MsgPackWriter, TestWriteInt32Min) {185 int64_t i = INT32_MIN;186 MPWriter.write(i);187 EXPECT_EQ(OStream.str(), std::string("\xd2\x80\x00\x00\x00", 5));188}189 190TEST_F(MsgPackWriter, TestWriteInt64Max) {191 int64_t i = static_cast<int64_t>(INT32_MIN) - 1;192 MPWriter.write(i);193 EXPECT_EQ(OStream.str(), "\xd3\xff\xff\xff\xff\x7f\xff\xff\xff");194}195 196TEST_F(MsgPackWriter, TestWriteInt64) {197 int64_t i = -1229782938247303441;198 MPWriter.write(i);199 EXPECT_EQ(OStream.str(), "\xd3\xee\xee\xee\xee\xee\xee\xee\xef");200}201 202TEST_F(MsgPackWriter, TestWriteInt64Min) {203 int64_t i = INT64_MIN;204 MPWriter.write(i);205 EXPECT_EQ(OStream.str(),206 std::string("\xd3\x80\x00\x00\x00\x00\x00\x00\x00", 9));207}208 209TEST_F(MsgPackWriter, TestWriteFloat32) {210 float f = -3.6973142664068907e+28;211 MPWriter.write(f);212 EXPECT_EQ(OStream.str(), "\xca\xee\xee\xee\xef");213}214 215TEST_F(MsgPackWriter, TestWriteFloat64) {216 double d = -2.2899894549927042e+226;217 MPWriter.write(d);218 EXPECT_EQ(OStream.str(), "\xcb\xee\xee\xee\xee\xee\xee\xee\xef");219}220 221TEST_F(MsgPackWriter, TestWriteFixStrMin) {222 std::string s;223 MPWriter.write(s);224 EXPECT_EQ(OStream.str(), "\xa0");225}226 227TEST_F(MsgPackWriter, TestWriteFixStr) {228 std::string s = "foo";229 MPWriter.write(s);230 EXPECT_EQ(OStream.str(), "\xa3"231 "foo");232}233 234TEST_F(MsgPackWriter, TestWriteFixStrMax) {235 // FixStr format's size is a 5 bit unsigned integer, so max is 11111 = 31236 std::string s(31, 'a');237 MPWriter.write(s);238 EXPECT_EQ(OStream.str(), std::string("\xbf") + s);239}240 241TEST_F(MsgPackWriter, TestWriteStr8Min) {242 // See TestWriteFixStrMax for why 32 is the min non-fix Str8243 std::string s(32, 'a');244 MPWriter.write(s);245 EXPECT_EQ(OStream.str(), std::string("\xd9\x20") + s);246}247 248TEST_F(MsgPackWriter, TestWriteStr8) {249 std::string s(33, 'a');250 MPWriter.write(s);251 EXPECT_EQ(OStream.str(), std::string("\xd9\x21") + s);252}253 254TEST_F(MsgPackWriter, TestWriteStr8Max) {255 std::string s(UINT8_MAX, 'a');256 MPWriter.write(s);257 EXPECT_EQ(OStream.str(), std::string("\xd9\xff") + s);258}259 260TEST_F(MsgPackWriter, TestWriteStr16Min) {261 std::string s(static_cast<uint64_t>(UINT8_MAX) + 1, 'a');262 MPWriter.write(s);263 EXPECT_EQ(OStream.str(), std::string("\xda\x01\x00", 3) + s);264}265 266TEST_F(MsgPackWriter, TestWriteStr16) {267 std::string s(511, 'a');268 MPWriter.write(s);269 EXPECT_EQ(OStream.str(), std::string("\xda\x01\xff") + s);270}271 272TEST_F(MsgPackWriter, TestWriteStr16Max) {273 std::string s(UINT16_MAX, 'a');274 MPWriter.write(s);275 EXPECT_EQ(OStream.str(), std::string("\xda\xff\xff") + s);276}277 278TEST_F(MsgPackWriter, TestWriteStr32Min) {279 std::string s(static_cast<uint64_t>(UINT16_MAX) + 1, 'a');280 MPWriter.write(s);281 EXPECT_EQ(OStream.str(), std::string("\xdb\x00\x01\x00\x00", 5) + s);282}283 284TEST_F(MsgPackWriter, TestWriteStr32) {285 std::string s(131071, 'a');286 MPWriter.write(s);287 EXPECT_EQ(OStream.str(), std::string("\xdb\x00\x01\xff\xff", 5) + s);288}289 290TEST_F(MsgPackWriter, TestWriteBin8Min) {291 std::string s;292 MPWriter.write(MemoryBufferRef(s, ""));293 EXPECT_EQ(OStream.str(), std::string("\xc4\x00", 2) + s);294}295 296TEST_F(MsgPackWriter, TestWriteBin8) {297 std::string s(5, 'a');298 MPWriter.write(MemoryBufferRef(s, ""));299 EXPECT_EQ(OStream.str(), std::string("\xc4\x05") + s);300}301 302TEST_F(MsgPackWriter, TestWriteBin8Max) {303 std::string s(UINT8_MAX, 'a');304 MPWriter.write(MemoryBufferRef(s, ""));305 EXPECT_EQ(OStream.str(), std::string("\xc4\xff") + s);306}307 308TEST_F(MsgPackWriter, TestWriteBin16Min) {309 std::string s(static_cast<uint64_t>(UINT8_MAX) + 1, 'a');310 MPWriter.write(MemoryBufferRef(s, ""));311 EXPECT_EQ(OStream.str(), std::string("\xc5\x01\x00", 3) + s);312}313 314TEST_F(MsgPackWriter, TestWriteBin16) {315 std::string s(511, 'a');316 MPWriter.write(MemoryBufferRef(s, ""));317 EXPECT_EQ(OStream.str(), "\xc5\x01\xff" + s);318}319 320TEST_F(MsgPackWriter, TestWriteBin16Max) {321 std::string s(UINT16_MAX, 'a');322 MPWriter.write(MemoryBufferRef(s, ""));323 EXPECT_EQ(OStream.str(), std::string("\xc5\xff\xff") + s);324}325 326TEST_F(MsgPackWriter, TestWriteBin32Min) {327 std::string s(static_cast<uint64_t>(UINT16_MAX) + 1, 'a');328 MPWriter.write(MemoryBufferRef(s, ""));329 EXPECT_EQ(OStream.str(), std::string("\xc6\x00\x01\x00\x00", 5) + s);330}331 332TEST_F(MsgPackWriter, TestWriteBin32) {333 std::string s(131071, 'a');334 MPWriter.write(MemoryBufferRef(s, ""));335 EXPECT_EQ(OStream.str(), std::string("\xc6\x00\x01\xff\xff", 5) + s);336}337 338TEST_F(MsgPackWriter, TestWriteFixArrayMin) {339 MPWriter.writeArraySize(0);340 EXPECT_EQ(OStream.str(), "\x90");341}342 343TEST_F(MsgPackWriter, TestWriteFixArray) {344 MPWriter.writeArraySize(4);345 EXPECT_EQ(OStream.str(), "\x94");346}347 348TEST_F(MsgPackWriter, TestWriteFixArrayMax) {349 // FixArray format's size is a 4 bit unsigned integer, so max is 1111 = 15350 MPWriter.writeArraySize(15);351 EXPECT_EQ(OStream.str(), "\x9f");352}353 354TEST_F(MsgPackWriter, TestWriteArray16Min) {355 // See TestWriteFixArrayMax for why 16 is the min non-fix Array16356 MPWriter.writeArraySize(16);357 EXPECT_EQ(OStream.str(), std::string("\xdc\x00\x10", 3));358}359 360TEST_F(MsgPackWriter, TestWriteArray16) {361 MPWriter.writeArraySize(273);362 EXPECT_EQ(OStream.str(), "\xdc\x01\x11");363}364 365TEST_F(MsgPackWriter, TestWriteArray16Max) {366 MPWriter.writeArraySize(UINT16_MAX);367 EXPECT_EQ(OStream.str(), "\xdc\xff\xff");368}369 370TEST_F(MsgPackWriter, TestWriteArray32Min) {371 MPWriter.writeArraySize(static_cast<uint64_t>(UINT16_MAX) + 1);372 EXPECT_EQ(OStream.str(), std::string("\xdd\x00\x01\x00\x00", 5));373}374 375TEST_F(MsgPackWriter, TestWriteArray32) {376 MPWriter.writeArraySize(131071);377 EXPECT_EQ(OStream.str(), std::string("\xdd\x00\x01\xff\xff", 5));378}379 380TEST_F(MsgPackWriter, TestWriteArray32Max) {381 MPWriter.writeArraySize(UINT32_MAX);382 EXPECT_EQ(OStream.str(), "\xdd\xff\xff\xff\xff");383}384 385TEST_F(MsgPackWriter, TestWriteFixMapMin) {386 MPWriter.writeMapSize(0);387 EXPECT_EQ(OStream.str(), "\x80");388}389 390TEST_F(MsgPackWriter, TestWriteFixMap) {391 MPWriter.writeMapSize(4);392 EXPECT_EQ(OStream.str(), "\x84");393}394 395TEST_F(MsgPackWriter, TestWriteFixMapMax) {396 // FixMap format's size is a 4 bit unsigned integer, so max is 1111 = 15397 MPWriter.writeMapSize(15);398 EXPECT_EQ(OStream.str(), "\x8f");399}400 401TEST_F(MsgPackWriter, TestWriteMap16Min) {402 // See TestWriteFixMapMax for why 16 is the min non-fix Map16403 MPWriter.writeMapSize(16);404 EXPECT_EQ(OStream.str(), std::string("\xde\x00\x10", 3));405}406 407TEST_F(MsgPackWriter, TestWriteMap16) {408 MPWriter.writeMapSize(273);409 EXPECT_EQ(OStream.str(), "\xde\x01\x11");410}411 412TEST_F(MsgPackWriter, TestWriteMap16Max) {413 MPWriter.writeMapSize(UINT16_MAX);414 EXPECT_EQ(OStream.str(), "\xde\xff\xff");415}416 417TEST_F(MsgPackWriter, TestWriteMap32Min) {418 MPWriter.writeMapSize(static_cast<uint64_t>(UINT16_MAX) + 1);419 EXPECT_EQ(OStream.str(), std::string("\xdf\x00\x01\x00\x00", 5));420}421 422TEST_F(MsgPackWriter, TestWriteMap32) {423 MPWriter.writeMapSize(131071);424 EXPECT_EQ(OStream.str(), std::string("\xdf\x00\x01\xff\xff", 5));425}426 427TEST_F(MsgPackWriter, TestWriteMap32Max) {428 MPWriter.writeMapSize(UINT32_MAX);429 EXPECT_EQ(OStream.str(), std::string("\xdf\xff\xff\xff\xff", 5));430}431 432// FixExt formats are only available for these specific lengths: 1, 2, 4, 8, 16433 434TEST_F(MsgPackWriter, TestWriteFixExt1) {435 std::string s(1, 'a');436 MPWriter.writeExt(0x01, MemoryBufferRef(s, ""));437 EXPECT_EQ(OStream.str(), std::string("\xd4\x01") + s);438}439 440TEST_F(MsgPackWriter, TestWriteFixExt2) {441 std::string s(2, 'a');442 MPWriter.writeExt(0x01, MemoryBufferRef(s, ""));443 EXPECT_EQ(OStream.str(), std::string("\xd5\x01") + s);444}445 446TEST_F(MsgPackWriter, TestWriteFixExt4) {447 std::string s(4, 'a');448 MPWriter.writeExt(0x01, MemoryBufferRef(s, ""));449 EXPECT_EQ(OStream.str(), std::string("\xd6\x01") + s);450}451 452TEST_F(MsgPackWriter, TestWriteFixExt8) {453 std::string s(8, 'a');454 MPWriter.writeExt(0x01, MemoryBufferRef(s, ""));455 EXPECT_EQ(OStream.str(), std::string("\xd7\x01") + s);456}457 458TEST_F(MsgPackWriter, TestWriteFixExt16) {459 std::string s(16, 'a');460 MPWriter.writeExt(0x01, MemoryBufferRef(s, ""));461 EXPECT_EQ(OStream.str(), std::string("\xd8\x01") + s);462}463 464TEST_F(MsgPackWriter, TestWriteExt8Min) {465 std::string s;466 MPWriter.writeExt(0x01, MemoryBufferRef(s, ""));467 EXPECT_EQ(OStream.str(), std::string("\xc7\x00\x01", 3) + s);468}469 470TEST_F(MsgPackWriter, TestWriteExt8) {471 std::string s(0x2a, 'a');472 MPWriter.writeExt(0x01, MemoryBufferRef(s, ""));473 EXPECT_EQ(OStream.str(), std::string("\xc7\x2a\x01") + s);474}475 476TEST_F(MsgPackWriter, TestWriteExt8Max) {477 std::string s(UINT8_MAX, 'a');478 MPWriter.writeExt(0x01, MemoryBufferRef(s, ""));479 EXPECT_EQ(OStream.str(), std::string("\xc7\xff\x01") + s);480}481 482TEST_F(MsgPackWriter, TestWriteExt16Min) {483 std::string s(static_cast<uint16_t>(UINT8_MAX) + 1, 'a');484 MPWriter.writeExt(0x02, MemoryBufferRef(s, ""));485 EXPECT_EQ(OStream.str(), std::string("\xc8\x01\x00\x02", 4) + s);486}487 488TEST_F(MsgPackWriter, TestWriteExt16) {489 std::string s(273, 'a');490 MPWriter.writeExt(0x01, MemoryBufferRef(s, ""));491 EXPECT_EQ(OStream.str(), std::string("\xc8\x01\x11\x01") + s);492}493 494TEST_F(MsgPackWriter, TestWriteExt16Max) {495 std::string s(UINT16_MAX, 'a');496 MPWriter.writeExt(0x01, MemoryBufferRef(s, ""));497 EXPECT_EQ(OStream.str(), std::string("\xc8\xff\xff\x01") + s);498}499 500TEST_F(MsgPackWriter, TestWriteExt32Min) {501 std::string s(static_cast<uint32_t>(UINT16_MAX) + 1, 'a');502 MPWriter.writeExt(0x02, MemoryBufferRef(s, ""));503 EXPECT_EQ(OStream.str(), std::string("\xc9\x00\x01\x00\x00\x02", 6) + s);504}505 506TEST_F(MsgPackWriter, TestWriteCompatibleNoStr8) {507 Writer CompatWriter(OStream, true);508 std::string s(32, 'a');509 CompatWriter.write(s);510 EXPECT_EQ(OStream.str(), std::string("\xda\x00\x20", 3) + s);511}512 513TEST_F(MsgPackWriter, TestWriteCompatibleNoBin) {514 Writer CompatWriter(OStream, true);515 std::string s;516 517#ifdef GTEST_HAS_DEATH_TEST518#ifndef NDEBUG519 EXPECT_DEATH(CompatWriter.write(MemoryBufferRef(s, "")), "compatible mode");520#endif521#endif522}523