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