unittests/Support/BinaryStreamTest.cpp

   1 //===- llvm/unittest/Support/BinaryStreamTest.cpp -------------------------===//
   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/Support/BinaryByteStream.h"
  11 #include "llvm/Support/BinaryItemStream.h"
  12 #include "llvm/Support/BinaryStreamArray.h"
  13 #include "llvm/Support/BinaryStreamReader.h"
  14 #include "llvm/Support/BinaryStreamRef.h"
  15 #include "llvm/Support/BinaryStreamWriter.h"
  16 #include "llvm/Testing/Support/Error.h"
  17
  18 #include "gtest/gtest.h"
  19
  20
  21 using namespace llvm;
  22 using namespace llvm::support;
  23
  24 namespace {
  25
  26 class BrokenStream : public WritableBinaryStream {
  27 public:
  28   BrokenStream(MutableArrayRef<uint8_t> Data, endianness Endian,
  29                       uint32_t Align)
  30       : Data(Data), PartitionIndex(alignDown(Data.size() / 2, Align)),
  31         Endian(Endian) {}
  32
  33   endianness getEndian() const override { return Endian; }
  34
  35   Error readBytes(uint32_t Offset, uint32_t Size,
  36                   ArrayRef<uint8_t> &Buffer) override {
  37     if (auto EC = checkOffsetForRead(Offset, Size))
  38       return EC;
  39     uint32_t S = startIndex(Offset);
  40     auto Ref = Data.drop_front(S);
  41     if (Ref.size() >= Size) {
  42       Buffer = Ref.take_front(Size);
  43       return Error::success();
  44     }
  45
  46     uint32_t BytesLeft = Size - Ref.size();
  47     uint8_t *Ptr = Allocator.Allocate<uint8_t>(Size);
  48     ::memcpy(Ptr, Ref.data(), Ref.size());
  49     ::memcpy(Ptr + Ref.size(), Data.data(), BytesLeft);
  50     Buffer = makeArrayRef<uint8_t>(Ptr, Size);
  51     return Error::success();
  52   }
  53
  54   Error readLongestContiguousChunk(uint32_t Offset,
  55                                    ArrayRef<uint8_t> &Buffer) override {
  56     if (auto EC = checkOffsetForRead(Offset, 1))
  57       return EC;
  58     uint32_t S = startIndex(Offset);
  59     Buffer = Data.drop_front(S);
  60     return Error::success();
  61   }
  62
  63   uint32_t getLength() override { return Data.size(); }
  64
  65   Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> SrcData) override {
  66     if (auto EC = checkOffsetForWrite(Offset, SrcData.size()))
  67       return EC;
  68     if (SrcData.empty())
  69       return Error::success();
  70
  71     uint32_t S = startIndex(Offset);
  72     MutableArrayRef<uint8_t> Ref(Data);
  73     Ref = Ref.drop_front(S);
  74     if (Ref.size() >= SrcData.size()) {
  75       ::memcpy(Ref.data(), SrcData.data(), SrcData.size());
  76       return Error::success();
  77     }
  78
  79     uint32_t BytesLeft = SrcData.size() - Ref.size();
  80     ::memcpy(Ref.data(), SrcData.data(), Ref.size());
  81     ::memcpy(&Data[0], SrcData.data() + Ref.size(), BytesLeft);
  82     return Error::success();
  83   }
  84   Error commit() override { return Error::success(); }
  85
  86 private:
  87   uint32_t startIndex(uint32_t Offset) const {
  88     return (Offset + PartitionIndex) % Data.size();
  89   }
  90
  91   uint32_t endIndex(uint32_t Offset, uint32_t Size) const {
  92     return (startIndex(Offset) + Size - 1) % Data.size();
  93   }
  94
  95   // Buffer is organized like this:
  96   // -------------------------------------------------
  97   // | N/2 | N/2+1 | ... | N-1 | 0 | 1 | ... | N/2-1 |
  98   // -------------------------------------------------
  99   // So reads from the beginning actually come from the middle.
 100   MutableArrayRef<uint8_t> Data;
 101   uint32_t PartitionIndex = 0;
 102   endianness Endian;
 103   BumpPtrAllocator Allocator;
 104 };
 105
 106 constexpr endianness Endians[] = {big, little, native};
 107 constexpr uint32_t NumEndians = llvm::array_lengthof(Endians);
 108 constexpr uint32_t NumStreams = 2 * NumEndians;
 109
 110 class BinaryStreamTest : public testing::Test {
 111
 112 public:
 113   BinaryStreamTest() {}
 114
 115   void SetUp() override {
 116     Streams.clear();
 117     Streams.resize(NumStreams);
 118     for (uint32_t I = 0; I < NumStreams; ++I)
 119       Streams[I].IsContiguous = (I % 2 == 0);
 120
 121     InputData.clear();
 122     OutputData.clear();
 123   }
 124
 125 protected:
 126   struct StreamPair {
 127     bool IsContiguous;
 128     std::unique_ptr<BinaryStream> Input;
 129     std::unique_ptr<WritableBinaryStream> Output;
 130   };
 131
 132   void initializeInput(ArrayRef<uint8_t> Input, uint32_t Align) {
 133     InputData = Input;
 134
 135     BrokenInputData.resize(InputData.size());
 136     if (!Input.empty()) {
 137       uint32_t PartitionIndex = alignDown(InputData.size() / 2, Align);
 138       uint32_t RightBytes = InputData.size() - PartitionIndex;
 139       uint32_t LeftBytes = PartitionIndex;
 140       if (RightBytes > 0)
 141         ::memcpy(&BrokenInputData[PartitionIndex], Input.data(), RightBytes);
 142       if (LeftBytes > 0)
 143         ::memcpy(&BrokenInputData[0], Input.data() + RightBytes, LeftBytes);
 144     }
 145
 146     for (uint32_t I = 0; I < NumEndians; ++I) {
 147       auto InByteStream =
 148           llvm::make_unique<BinaryByteStream>(InputData, Endians[I]);
 149       auto InBrokenStream = llvm::make_unique<BrokenStream>(
 150           BrokenInputData, Endians[I], Align);
 151
 152       Streams[I * 2].Input = std::move(InByteStream);
 153       Streams[I * 2 + 1].Input = std::move(InBrokenStream);
 154     }
 155   }
 156
 157   void initializeOutput(uint32_t Size, uint32_t Align) {
 158     OutputData.resize(Size);
 159     BrokenOutputData.resize(Size);
 160
 161     for (uint32_t I = 0; I < NumEndians; ++I) {
 162       Streams[I * 2].Output =
 163           llvm::make_unique<MutableBinaryByteStream>(OutputData, Endians[I]);
 164       Streams[I * 2 + 1].Output = llvm::make_unique<BrokenStream>(
 165           BrokenOutputData, Endians[I], Align);
 166     }
 167   }
 168
 169   void initializeOutputFromInput(uint32_t Align) {
 170     for (uint32_t I = 0; I < NumEndians; ++I) {
 171       Streams[I * 2].Output =
 172           llvm::make_unique<MutableBinaryByteStream>(InputData, Endians[I]);
 173       Streams[I * 2 + 1].Output = llvm::make_unique<BrokenStream>(
 174           BrokenInputData, Endians[I], Align);
 175     }
 176   }
 177
 178   void initializeInputFromOutput(uint32_t Align) {
 179     for (uint32_t I = 0; I < NumEndians; ++I) {
 180       Streams[I * 2].Input =
 181           llvm::make_unique<BinaryByteStream>(OutputData, Endians[I]);
 182       Streams[I * 2 + 1].Input = llvm::make_unique<BrokenStream>(
 183           BrokenOutputData, Endians[I], Align);
 184     }
 185   }
 186
 187   std::vector<uint8_t> InputData;
 188   std::vector<uint8_t> BrokenInputData;
 189
 190   std::vector<uint8_t> OutputData;
 191   std::vector<uint8_t> BrokenOutputData;
 192
 193   std::vector<StreamPair> Streams;
 194 };
 195
 196 // Tests that a we can read from a BinaryByteStream without a StreamReader.
 197 TEST_F(BinaryStreamTest, BinaryByteStreamBounds) {
 198   std::vector<uint8_t> InputData = {1, 2, 3, 4, 5};
 199   initializeInput(InputData, 1);
 200
 201   for (auto &Stream : Streams) {
 202     ArrayRef<uint8_t> Buffer;
 203
 204     // 1. If the read fits it should work.
 205     ASSERT_EQ(InputData.size(), Stream.Input->getLength());
 206     ASSERT_THAT_ERROR(Stream.Input->readBytes(2, 1, Buffer), Succeeded());
 207     EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer);
 208     ASSERT_THAT_ERROR(Stream.Input->readBytes(0, 4, Buffer), Succeeded());
 209     EXPECT_EQ(makeArrayRef(InputData).slice(0, 4), Buffer);
 210
 211     // 2. Reading past the bounds of the input should fail.
 212     EXPECT_THAT_ERROR(Stream.Input->readBytes(4, 2, Buffer), Failed());
 213   }
 214 }
 215
 216 TEST_F(BinaryStreamTest, StreamRefBounds) {
 217   std::vector<uint8_t> InputData = {1, 2, 3, 4, 5};
 218   initializeInput(InputData, 1);
 219
 220   for (const auto &Stream : Streams) {
 221     ArrayRef<uint8_t> Buffer;
 222     BinaryStreamRef Ref(*Stream.Input);
 223
 224     // Read 1 byte from offset 2 should work
 225     ASSERT_EQ(InputData.size(), Ref.getLength());
 226     ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded());
 227     EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer);
 228
 229     // Reading everything from offset 2 on.
 230     ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
 231     if (Stream.IsContiguous)
 232       EXPECT_EQ(makeArrayRef(InputData).slice(2), Buffer);
 233     else
 234       EXPECT_FALSE(Buffer.empty());
 235
 236     // Reading 6 bytes from offset 0 is too big.
 237     EXPECT_THAT_ERROR(Ref.readBytes(0, 6, Buffer), Failed());
 238     EXPECT_THAT_ERROR(Ref.readLongestContiguousChunk(6, Buffer), Failed());
 239
 240     // Reading 1 byte from offset 2 after dropping 1 byte is the same as reading
 241     // 1 byte from offset 3.
 242     Ref = Ref.drop_front(1);
 243     ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded());
 244     if (Stream.IsContiguous)
 245       EXPECT_EQ(makeArrayRef(InputData).slice(3, 1), Buffer);
 246     else
 247       EXPECT_FALSE(Buffer.empty());
 248
 249     // Reading everything from offset 2 on after dropping 1 byte.
 250     ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
 251     if (Stream.IsContiguous)
 252       EXPECT_EQ(makeArrayRef(InputData).slice(3), Buffer);
 253     else
 254       EXPECT_FALSE(Buffer.empty());
 255
 256     // Reading 2 bytes from offset 2 after dropping 2 bytes is the same as
 257     // reading 2 bytes from offset 4, and should fail.
 258     Ref = Ref.drop_front(1);
 259     EXPECT_THAT_ERROR(Ref.readBytes(2, 2, Buffer), Failed());
 260
 261     // But if we read the longest contiguous chunk instead, we should still
 262     // get the 1 byte at the end.
 263     ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
 264     EXPECT_EQ(makeArrayRef(InputData).take_back(), Buffer);
 265   }
 266 }
 267
 268 TEST_F(BinaryStreamTest, StreamRefDynamicSize) {
 269   StringRef Strings[] = {"1", "2", "3", "4"};
 270   AppendingBinaryByteStream Stream(support::little);
 271
 272   BinaryStreamWriter Writer(Stream);
 273   BinaryStreamReader Reader(Stream);
 274   const uint8_t *Byte;
 275   StringRef Str;
 276
 277   // When the stream is empty, it should report a 0 length and we should get an
 278   // error trying to read even 1 byte from it.
 279   BinaryStreamRef ConstRef(Stream);
 280   EXPECT_EQ(0U, ConstRef.getLength());
 281   EXPECT_THAT_ERROR(Reader.readObject(Byte), Failed());
 282
 283   // But if we write to it, its size should increase and we should be able to
 284   // read not just a byte, but the string that was written.
 285   EXPECT_THAT_ERROR(Writer.writeCString(Strings[0]), Succeeded());
 286   EXPECT_EQ(2U, ConstRef.getLength());
 287   EXPECT_THAT_ERROR(Reader.readObject(Byte), Succeeded());
 288
 289   Reader.setOffset(0);
 290   EXPECT_THAT_ERROR(Reader.readCString(Str), Succeeded());
 291   EXPECT_EQ(Str, Strings[0]);
 292
 293   // If we drop some bytes from the front, we should still track the length as
 294   // the
 295   // underlying stream grows.
 296   BinaryStreamRef Dropped = ConstRef.drop_front(1);
 297   EXPECT_EQ(1U, Dropped.getLength());
 298
 299   EXPECT_THAT_ERROR(Writer.writeCString(Strings[1]), Succeeded());
 300   EXPECT_EQ(4U, ConstRef.getLength());
 301   EXPECT_EQ(3U, Dropped.getLength());
 302
 303   // If we drop zero bytes from the back, we should continue tracking the
 304   // length.
 305   Dropped = Dropped.drop_back(0);
 306   EXPECT_THAT_ERROR(Writer.writeCString(Strings[2]), Succeeded());
 307   EXPECT_EQ(6U, ConstRef.getLength());
 308   EXPECT_EQ(5U, Dropped.getLength());
 309
 310   // If we drop non-zero bytes from the back, we should stop tracking the
 311   // length.
 312   Dropped = Dropped.drop_back(1);
 313   EXPECT_THAT_ERROR(Writer.writeCString(Strings[3]), Succeeded());
 314   EXPECT_EQ(8U, ConstRef.getLength());
 315   EXPECT_EQ(4U, Dropped.getLength());
 316 }
 317
 318 TEST_F(BinaryStreamTest, DropOperations) {
 319   std::vector<uint8_t> InputData = {1, 2, 3, 4, 5, 4, 3, 2, 1};
 320   auto RefData = makeArrayRef(InputData);
 321   initializeInput(InputData, 1);
 322
 323   ArrayRef<uint8_t> Result;
 324   BinaryStreamRef Original(InputData, support::little);
 325   ASSERT_EQ(InputData.size(), Original.getLength());
 326
 327   EXPECT_THAT_ERROR(Original.readBytes(0, InputData.size(), Result),
 328                     Succeeded());
 329   EXPECT_EQ(RefData, Result);
 330
 331   auto Dropped = Original.drop_front(2);
 332   EXPECT_THAT_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result),
 333                     Succeeded());
 334   EXPECT_EQ(RefData.drop_front(2), Result);
 335
 336   Dropped = Original.drop_back(2);
 337   EXPECT_THAT_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result),
 338                     Succeeded());
 339   EXPECT_EQ(RefData.drop_back(2), Result);
 340
 341   Dropped = Original.keep_front(2);
 342   EXPECT_THAT_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result),
 343                     Succeeded());
 344   EXPECT_EQ(RefData.take_front(2), Result);
 345
 346   Dropped = Original.keep_back(2);
 347   EXPECT_THAT_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result),
 348                     Succeeded());
 349   EXPECT_EQ(RefData.take_back(2), Result);
 350
 351   Dropped = Original.drop_symmetric(2);
 352   EXPECT_THAT_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result),
 353                     Succeeded());
 354   EXPECT_EQ(RefData.drop_front(2).drop_back(2), Result);
 355 }
 356
 357 // Test that we can write to a BinaryStream without a StreamWriter.
 358 TEST_F(BinaryStreamTest, MutableBinaryByteStreamBounds) {
 359   std::vector<uint8_t> InputData = {'T', 'e', 's', 't', '\0'};
 360   initializeInput(InputData, 1);
 361   initializeOutput(InputData.size(), 1);
 362
 363   // For every combination of input stream and output stream.
 364   for (auto &Stream : Streams) {
 365     ASSERT_EQ(InputData.size(), Stream.Input->getLength());
 366
 367     // 1. Try two reads that are supposed to work.  One from offset 0, and one
 368     // from the middle.
 369     uint32_t Offsets[] = {0, 3};
 370     for (auto Offset : Offsets) {
 371       uint32_t ExpectedSize = Stream.Input->getLength() - Offset;
 372
 373       // Read everything from Offset until the end of the input data.
 374       ArrayRef<uint8_t> Data;
 375       ASSERT_THAT_ERROR(Stream.Input->readBytes(Offset, ExpectedSize, Data),
 376                         Succeeded());
 377       ASSERT_EQ(ExpectedSize, Data.size());
 378
 379       // Then write it to the destination.
 380       ASSERT_THAT_ERROR(Stream.Output->writeBytes(0, Data), Succeeded());
 381
 382       // Then we read back what we wrote, it should match the corresponding
 383       // slice of the original input data.
 384       ArrayRef<uint8_t> Data2;
 385       ASSERT_THAT_ERROR(Stream.Output->readBytes(Offset, ExpectedSize, Data2),
 386                         Succeeded());
 387       EXPECT_EQ(makeArrayRef(InputData).drop_front(Offset), Data2);
 388     }
 389
 390     std::vector<uint8_t> BigData = {0, 1, 2, 3, 4};
 391     // 2. If the write is too big, it should fail.
 392     EXPECT_THAT_ERROR(Stream.Output->writeBytes(3, BigData), Failed());
 393   }
 394 }
 395
 396 TEST_F(BinaryStreamTest, AppendingStream) {
 397   AppendingBinaryByteStream Stream(llvm::support::little);
 398   EXPECT_EQ(0U, Stream.getLength());
 399
 400   std::vector<uint8_t> InputData = {'T', 'e', 's', 't', 'T', 'e', 's', 't'};
 401   auto Test = makeArrayRef(InputData).take_front(4);
 402   // Writing past the end of the stream is an error.
 403   EXPECT_THAT_ERROR(Stream.writeBytes(4, Test), Failed());
 404
 405   // Writing exactly at the end of the stream is ok.
 406   EXPECT_THAT_ERROR(Stream.writeBytes(0, Test), Succeeded());
 407   EXPECT_EQ(Test, Stream.data());
 408
 409   // And now that the end of the stream is where we couldn't write before, now
 410   // we can write.
 411   EXPECT_THAT_ERROR(Stream.writeBytes(4, Test), Succeeded());
 412   EXPECT_EQ(MutableArrayRef<uint8_t>(InputData), Stream.data());
 413 }
 414
 415 // Test that FixedStreamArray works correctly.
 416 TEST_F(BinaryStreamTest, FixedStreamArray) {
 417   std::vector<uint32_t> Ints = {90823, 12908, 109823, 209823};
 418   ArrayRef<uint8_t> IntBytes(reinterpret_cast<uint8_t *>(Ints.data()),
 419                              Ints.size() * sizeof(uint32_t));
 420
 421   initializeInput(IntBytes, alignof(uint32_t));
 422
 423   for (auto &Stream : Streams) {
 424     ASSERT_EQ(InputData.size(), Stream.Input->getLength());
 425
 426     FixedStreamArray<uint32_t> Array(*Stream.Input);
 427     auto Iter = Array.begin();
 428     ASSERT_EQ(Ints[0], *Iter++);
 429     ASSERT_EQ(Ints[1], *Iter++);
 430     ASSERT_EQ(Ints[2], *Iter++);
 431     ASSERT_EQ(Ints[3], *Iter++);
 432     ASSERT_EQ(Array.end(), Iter);
 433   }
 434 }
 435
 436 // Ensure FixedStreamArrayIterator::operator-> works.
 437 // Added for coverage of r302257.
 438 TEST_F(BinaryStreamTest, FixedStreamArrayIteratorArrow) {
 439   std::vector<std::pair<uint32_t, uint32_t>> Pairs = {{867, 5309}, {555, 1212}};
 440   ArrayRef<uint8_t> PairBytes(reinterpret_cast<uint8_t *>(Pairs.data()),
 441     Pairs.size() * sizeof(Pairs[0]));
 442
 443   initializeInput(PairBytes, alignof(uint32_t));
 444
 445   for (auto &Stream : Streams) {
 446     ASSERT_EQ(InputData.size(), Stream.Input->getLength());
 447
 448     const FixedStreamArray<std::pair<uint32_t, uint32_t>> Array(*Stream.Input);
 449     auto Iter = Array.begin();
 450     ASSERT_EQ(Pairs[0].first, Iter->first);
 451     ASSERT_EQ(Pairs[0].second, Iter->second);
 452     ++Iter;
 453     ASSERT_EQ(Pairs[1].first, Iter->first);
 454     ASSERT_EQ(Pairs[1].second, Iter->second);
 455     ++Iter;
 456     ASSERT_EQ(Array.end(), Iter);
 457   }
 458 }
 459
 460 // Test that VarStreamArray works correctly.
 461 TEST_F(BinaryStreamTest, VarStreamArray) {
 462   StringLiteral Strings("1. Test2. Longer Test3. Really Long Test4. Super "
 463                         "Extra Longest Test Of All");
 464   ArrayRef<uint8_t> StringBytes(
 465       reinterpret_cast<const uint8_t *>(Strings.data()), Strings.size());
 466   initializeInput(StringBytes, 1);
 467
 468   struct StringExtractor {
 469   public:
 470     Error operator()(BinaryStreamRef Stream, uint32_t &Len, StringRef &Item) {
 471       if (Index == 0)
 472         Len = strlen("1. Test");
 473       else if (Index == 1)
 474         Len = strlen("2. Longer Test");
 475       else if (Index == 2)
 476         Len = strlen("3. Really Long Test");
 477       else
 478         Len = strlen("4. Super Extra Longest Test Of All");
 479       ArrayRef<uint8_t> Bytes;
 480       if (auto EC = Stream.readBytes(0, Len, Bytes))
 481         return EC;
 482       Item =
 483           StringRef(reinterpret_cast<const char *>(Bytes.data()), Bytes.size());
 484       ++Index;
 485       return Error::success();
 486     }
 487
 488     uint32_t Index = 0;
 489   };
 490
 491   for (auto &Stream : Streams) {
 492     VarStreamArray<StringRef, StringExtractor> Array(*Stream.Input);
 493     auto Iter = Array.begin();
 494     ASSERT_EQ("1. Test", *Iter++);
 495     ASSERT_EQ("2. Longer Test", *Iter++);
 496     ASSERT_EQ("3. Really Long Test", *Iter++);
 497     ASSERT_EQ("4. Super Extra Longest Test Of All", *Iter++);
 498     ASSERT_EQ(Array.end(), Iter);
 499   }
 500 }
 501
 502 TEST_F(BinaryStreamTest, StreamReaderBounds) {
 503   std::vector<uint8_t> Bytes;
 504
 505   initializeInput(Bytes, 1);
 506   for (auto &Stream : Streams) {
 507     StringRef S;
 508     BinaryStreamReader Reader(*Stream.Input);
 509     EXPECT_EQ(0U, Reader.bytesRemaining());
 510     EXPECT_THAT_ERROR(Reader.readFixedString(S, 1), Failed());
 511   }
 512
 513   Bytes.resize(5);
 514   initializeInput(Bytes, 1);
 515   for (auto &Stream : Streams) {
 516     StringRef S;
 517     BinaryStreamReader Reader(*Stream.Input);
 518     EXPECT_EQ(Bytes.size(), Reader.bytesRemaining());
 519     EXPECT_THAT_ERROR(Reader.readFixedString(S, 5), Succeeded());
 520     EXPECT_THAT_ERROR(Reader.readFixedString(S, 6), Failed());
 521   }
 522 }
 523
 524 TEST_F(BinaryStreamTest, StreamReaderIntegers) {
 525   support::ulittle64_t Little{908234};
 526   support::ubig32_t Big{28907823};
 527   short NS = 2897;
 528   int NI = -89723;
 529   unsigned long NUL = 902309023UL;
 530   constexpr uint32_t Size =
 531       sizeof(Little) + sizeof(Big) + sizeof(NS) + sizeof(NI) + sizeof(NUL);
 532
 533   initializeOutput(Size, alignof(support::ulittle64_t));
 534   initializeInputFromOutput(alignof(support::ulittle64_t));
 535
 536   for (auto &Stream : Streams) {
 537     BinaryStreamWriter Writer(*Stream.Output);
 538     ASSERT_THAT_ERROR(Writer.writeObject(Little), Succeeded());
 539     ASSERT_THAT_ERROR(Writer.writeObject(Big), Succeeded());
 540     ASSERT_THAT_ERROR(Writer.writeInteger(NS), Succeeded());
 541     ASSERT_THAT_ERROR(Writer.writeInteger(NI), Succeeded());
 542     ASSERT_THAT_ERROR(Writer.writeInteger(NUL), Succeeded());
 543
 544     const support::ulittle64_t *Little2;
 545     const support::ubig32_t *Big2;
 546     short NS2;
 547     int NI2;
 548     unsigned long NUL2;
 549
 550     // 1. Reading fields individually.
 551     BinaryStreamReader Reader(*Stream.Input);
 552     ASSERT_THAT_ERROR(Reader.readObject(Little2), Succeeded());
 553     ASSERT_THAT_ERROR(Reader.readObject(Big2), Succeeded());
 554     ASSERT_THAT_ERROR(Reader.readInteger(NS2), Succeeded());
 555     ASSERT_THAT_ERROR(Reader.readInteger(NI2), Succeeded());
 556     ASSERT_THAT_ERROR(Reader.readInteger(NUL2), Succeeded());
 557     ASSERT_EQ(0U, Reader.bytesRemaining());
 558
 559     EXPECT_EQ(Little, *Little2);
 560     EXPECT_EQ(Big, *Big2);
 561     EXPECT_EQ(NS, NS2);
 562     EXPECT_EQ(NI, NI2);
 563     EXPECT_EQ(NUL, NUL2);
 564   }
 565 }
 566
 567 TEST_F(BinaryStreamTest, StreamReaderIntegerArray) {
 568   // 1. Arrays of integers
 569   std::vector<int> Ints = {1, 2, 3, 4, 5};
 570   ArrayRef<uint8_t> IntBytes(reinterpret_cast<uint8_t *>(&Ints[0]),
 571                              Ints.size() * sizeof(int));
 572
 573   initializeInput(IntBytes, alignof(int));
 574   for (auto &Stream : Streams) {
 575     BinaryStreamReader Reader(*Stream.Input);
 576     ArrayRef<int> IntsRef;
 577     ASSERT_THAT_ERROR(Reader.readArray(IntsRef, Ints.size()), Succeeded());
 578     ASSERT_EQ(0U, Reader.bytesRemaining());
 579     EXPECT_EQ(makeArrayRef(Ints), IntsRef);
 580
 581     Reader.setOffset(0);
 582     FixedStreamArray<int> FixedIntsRef;
 583     ASSERT_THAT_ERROR(Reader.readArray(FixedIntsRef, Ints.size()), Succeeded());
 584     ASSERT_EQ(0U, Reader.bytesRemaining());
 585     ASSERT_EQ(Ints, std::vector<int>(FixedIntsRef.begin(), FixedIntsRef.end()));
 586   }
 587 }
 588
 589 TEST_F(BinaryStreamTest, StreamReaderEnum) {
 590   enum class MyEnum : int64_t { Foo = -10, Bar = 0, Baz = 10 };
 591
 592   std::vector<MyEnum> Enums = {MyEnum::Bar, MyEnum::Baz, MyEnum::Foo};
 593
 594   initializeOutput(Enums.size() * sizeof(MyEnum), alignof(MyEnum));
 595   initializeInputFromOutput(alignof(MyEnum));
 596   for (auto &Stream : Streams) {
 597     BinaryStreamWriter Writer(*Stream.Output);
 598     for (auto Value : Enums)
 599       ASSERT_THAT_ERROR(Writer.writeEnum(Value), Succeeded());
 600
 601     BinaryStreamReader Reader(*Stream.Input);
 602
 603     FixedStreamArray<MyEnum> FSA;
 604
 605     for (size_t I = 0; I < Enums.size(); ++I) {
 606       MyEnum Value;
 607       ASSERT_THAT_ERROR(Reader.readEnum(Value), Succeeded());
 608       EXPECT_EQ(Enums[I], Value);
 609     }
 610     ASSERT_EQ(0U, Reader.bytesRemaining());
 611   }
 612 }
 613
 614 TEST_F(BinaryStreamTest, StreamReaderObject) {
 615   struct Foo {
 616     int X;
 617     double Y;
 618     char Z;
 619
 620     bool operator==(const Foo &Other) const {
 621       return X == Other.X && Y == Other.Y && Z == Other.Z;
 622     }
 623   };
 624
 625   std::vector<Foo> Foos;
 626   Foos.push_back({-42, 42.42, 42});
 627   Foos.push_back({100, 3.1415, static_cast<char>(-89)});
 628   Foos.push_back({200, 2.718, static_cast<char>(-12) });
 629
 630   const uint8_t *Bytes = reinterpret_cast<const uint8_t *>(&Foos[0]);
 631
 632   initializeInput(makeArrayRef(Bytes, 3 * sizeof(Foo)), alignof(Foo));
 633
 634   for (auto &Stream : Streams) {
 635     // 1. Reading object pointers.
 636     BinaryStreamReader Reader(*Stream.Input);
 637     const Foo *FPtrOut = nullptr;
 638     const Foo *GPtrOut = nullptr;
 639     const Foo *HPtrOut = nullptr;
 640     ASSERT_THAT_ERROR(Reader.readObject(FPtrOut), Succeeded());
 641     ASSERT_THAT_ERROR(Reader.readObject(GPtrOut), Succeeded());
 642     ASSERT_THAT_ERROR(Reader.readObject(HPtrOut), Succeeded());
 643     EXPECT_EQ(0U, Reader.bytesRemaining());
 644     EXPECT_EQ(Foos[0], *FPtrOut);
 645     EXPECT_EQ(Foos[1], *GPtrOut);
 646     EXPECT_EQ(Foos[2], *HPtrOut);
 647   }
 648 }
 649
 650 TEST_F(BinaryStreamTest, StreamReaderStrings) {
 651   std::vector<uint8_t> Bytes = {'O',  'n', 'e', '\0', 'T', 'w', 'o',
 652                                 '\0', 'T', 'h', 'r',  'e', 'e', '\0',
 653                                 'F',  'o', 'u', 'r',  '\0'};
 654   initializeInput(Bytes, 1);
 655
 656   for (auto &Stream : Streams) {
 657     BinaryStreamReader Reader(*Stream.Input);
 658
 659     StringRef S1;
 660     StringRef S2;
 661     StringRef S3;
 662     StringRef S4;
 663     ASSERT_THAT_ERROR(Reader.readCString(S1), Succeeded());
 664     ASSERT_THAT_ERROR(Reader.readCString(S2), Succeeded());
 665     ASSERT_THAT_ERROR(Reader.readCString(S3), Succeeded());
 666     ASSERT_THAT_ERROR(Reader.readCString(S4), Succeeded());
 667     ASSERT_EQ(0U, Reader.bytesRemaining());
 668
 669     EXPECT_EQ("One", S1);
 670     EXPECT_EQ("Two", S2);
 671     EXPECT_EQ("Three", S3);
 672     EXPECT_EQ("Four", S4);
 673
 674     S1 = S2 = S3 = S4 = "";
 675     Reader.setOffset(0);
 676     ASSERT_THAT_ERROR(Reader.readFixedString(S1, 3), Succeeded());
 677     ASSERT_THAT_ERROR(Reader.skip(1), Succeeded());
 678     ASSERT_THAT_ERROR(Reader.readFixedString(S2, 3), Succeeded());
 679     ASSERT_THAT_ERROR(Reader.skip(1), Succeeded());
 680     ASSERT_THAT_ERROR(Reader.readFixedString(S3, 5), Succeeded());
 681     ASSERT_THAT_ERROR(Reader.skip(1), Succeeded());
 682     ASSERT_THAT_ERROR(Reader.readFixedString(S4, 4), Succeeded());
 683     ASSERT_THAT_ERROR(Reader.skip(1), Succeeded());
 684     ASSERT_EQ(0U, Reader.bytesRemaining());
 685
 686     EXPECT_EQ("One", S1);
 687     EXPECT_EQ("Two", S2);
 688     EXPECT_EQ("Three", S3);
 689     EXPECT_EQ("Four", S4);
 690   }
 691 }
 692
 693 TEST_F(BinaryStreamTest, StreamWriterBounds) {
 694   initializeOutput(5, 1);
 695
 696   for (auto &Stream : Streams) {
 697     BinaryStreamWriter Writer(*Stream.Output);
 698
 699     // 1. Can write a string that exactly fills the buffer.
 700     EXPECT_EQ(5U, Writer.bytesRemaining());
 701     EXPECT_THAT_ERROR(Writer.writeFixedString("abcde"), Succeeded());
 702     EXPECT_EQ(0U, Writer.bytesRemaining());
 703
 704     // 2. Can write an empty string even when you're full
 705     EXPECT_THAT_ERROR(Writer.writeFixedString(""), Succeeded());
 706     EXPECT_THAT_ERROR(Writer.writeFixedString("a"), Failed());
 707
 708     // 3. Can't write a string that is one character too long.
 709     Writer.setOffset(0);
 710     EXPECT_THAT_ERROR(Writer.writeFixedString("abcdef"), Failed());
 711   }
 712 }
 713
 714 TEST_F(BinaryStreamTest, StreamWriterIntegerArrays) {
 715   // 3. Arrays of integers
 716   std::vector<int> SourceInts = {1, 2, 3, 4, 5};
 717   ArrayRef<uint8_t> SourceBytes(reinterpret_cast<uint8_t *>(&SourceInts[0]),
 718                                 SourceInts.size() * sizeof(int));
 719
 720   initializeInput(SourceBytes, alignof(int));
 721   initializeOutputFromInput(alignof(int));
 722
 723   for (auto &Stream : Streams) {
 724     BinaryStreamReader Reader(*Stream.Input);
 725     BinaryStreamWriter Writer(*Stream.Output);
 726     ArrayRef<int> Ints;
 727     ArrayRef<int> Ints2;
 728     // First read them, then write them, then read them back.
 729     ASSERT_THAT_ERROR(Reader.readArray(Ints, SourceInts.size()), Succeeded());
 730     ASSERT_THAT_ERROR(Writer.writeArray(Ints), Succeeded());
 731
 732     BinaryStreamReader ReaderBacker(*Stream.Output);
 733     ASSERT_THAT_ERROR(ReaderBacker.readArray(Ints2, SourceInts.size()),
 734                       Succeeded());
 735
 736     EXPECT_EQ(makeArrayRef(SourceInts), Ints2);
 737   }
 738 }
 739
 740 TEST_F(BinaryStreamTest, StringWriterStrings) {
 741   StringRef Strings[] = {"First", "Second", "Third", "Fourth"};
 742
 743   size_t Length = 0;
 744   for (auto S : Strings)
 745     Length += S.size() + 1;
 746   initializeOutput(Length, 1);
 747   initializeInputFromOutput(1);
 748
 749   for (auto &Stream : Streams) {
 750     BinaryStreamWriter Writer(*Stream.Output);
 751     for (auto S : Strings)
 752       ASSERT_THAT_ERROR(Writer.writeCString(S), Succeeded());
 753     std::vector<StringRef> InStrings;
 754     BinaryStreamReader Reader(*Stream.Input);
 755     while (!Reader.empty()) {
 756       StringRef S;
 757       ASSERT_THAT_ERROR(Reader.readCString(S), Succeeded());
 758       InStrings.push_back(S);
 759     }
 760     EXPECT_EQ(makeArrayRef(Strings), makeArrayRef(InStrings));
 761   }
 762 }
 763
 764 TEST_F(BinaryStreamTest, StreamWriterAppend) {
 765   StringRef Strings[] = {"First", "Second", "Third", "Fourth"};
 766   AppendingBinaryByteStream Stream(support::little);
 767   BinaryStreamWriter Writer(Stream);
 768
 769   for (auto &Str : Strings) {
 770     EXPECT_THAT_ERROR(Writer.writeCString(Str), Succeeded());
 771   }
 772
 773   BinaryStreamReader Reader(Stream);
 774   for (auto &Str : Strings) {
 775     StringRef S;
 776     EXPECT_THAT_ERROR(Reader.readCString(S), Succeeded());
 777     EXPECT_EQ(Str, S);
 778   }
 779 }
 780 }
 781
 782 namespace {
 783 struct BinaryItemStreamObject {
 784   explicit BinaryItemStreamObject(ArrayRef<uint8_t> Bytes) : Bytes(Bytes) {}
 785
 786   ArrayRef<uint8_t> Bytes;
 787 };
 788 }
 789
 790 namespace llvm {
 791 template <> struct BinaryItemTraits<BinaryItemStreamObject> {
 792   static size_t length(const BinaryItemStreamObject &Item) {
 793     return Item.Bytes.size();
 794   }
 795
 796   static ArrayRef<uint8_t> bytes(const BinaryItemStreamObject &Item) {
 797     return Item.Bytes;
 798   }
 799 };
 800 }
 801
 802 namespace {
 803
 804 TEST_F(BinaryStreamTest, BinaryItemStream) {
 805   std::vector<BinaryItemStreamObject> Objects;
 806
 807   struct Foo {
 808     int X;
 809     double Y;
 810   };
 811   std::vector<Foo> Foos = {{1, 1.0}, {2, 2.0}, {3, 3.0}};
 812   BumpPtrAllocator Allocator;
 813   for (const auto &F : Foos) {
 814     uint8_t *Ptr = static_cast<uint8_t *>(Allocator.Allocate(sizeof(Foo),
 815                                                              alignof(Foo)));
 816     MutableArrayRef<uint8_t> Buffer(Ptr, sizeof(Foo));
 817     MutableBinaryByteStream Stream(Buffer, llvm::support::big);
 818     BinaryStreamWriter Writer(Stream);
 819     ASSERT_THAT_ERROR(Writer.writeObject(F), Succeeded());
 820     Objects.push_back(BinaryItemStreamObject(Buffer));
 821   }
 822
 823   BinaryItemStream<BinaryItemStreamObject> ItemStream(big);
 824   ItemStream.setItems(Objects);
 825   BinaryStreamReader Reader(ItemStream);
 826
 827   for (const auto &F : Foos) {
 828     const Foo *F2;
 829     ASSERT_THAT_ERROR(Reader.readObject(F2), Succeeded());
 830
 831     EXPECT_EQ(F.X, F2->X);
 832     EXPECT_DOUBLE_EQ(F.Y, F2->Y);
 833   }
 834 }
 835
 836 } // end anonymous namespace