1 //===- llvm/unittest/DebugInfo/MSF/MappedBlockStreamTest.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/DebugInfo/MSF/MappedBlockStream.h" 11 #include "llvm/DebugInfo/MSF/IMSFFile.h" 12 #include "llvm/DebugInfo/MSF/MSFError.h" 13 #include "llvm/Support/BinaryByteStream.h" 14 #include "llvm/Support/BinaryStreamReader.h" 15 #include "llvm/Support/BinaryStreamRef.h" 16 #include "llvm/Support/BinaryStreamWriter.h" 17 #include "llvm/Testing/Support/Error.h" 18 19 #include "gmock/gmock.h" 20 #include "gtest/gtest.h" 21 22 #include <unordered_map> 23 24 using namespace llvm; 25 using namespace llvm::msf; 26 using namespace llvm::support; 27 28 namespace { 29 30 static const uint32_t BlocksAry[] = {0, 1, 2, 5, 4, 3, 6, 7, 8, 9}; 31 static uint8_t DataAry[] = {'A', 'B', 'C', 'F', 'E', 'D', 'G', 'H', 'I', 'J'}; 32 33 class DiscontiguousStream : public WritableBinaryStream { 34 public: 35 DiscontiguousStream(ArrayRef<uint32_t> Blocks, MutableArrayRef<uint8_t> Data) 36 : Blocks(Blocks.begin(), Blocks.end()), Data(Data.begin(), Data.end()) {} 37 38 uint32_t block_size() const { return 1; } 39 uint32_t block_count() const { return Blocks.size(); } 40 41 endianness getEndian() const override { return little; } 42 43 Error readBytes(uint32_t Offset, uint32_t Size, 44 ArrayRef<uint8_t> &Buffer) override { 45 if (auto EC = checkOffset(Offset, Size)) 46 return EC; 47 Buffer = Data.slice(Offset, Size); 48 return Error::success(); 49 } 50 51 Error readLongestContiguousChunk(uint32_t Offset, 52 ArrayRef<uint8_t> &Buffer) override { 53 if (auto EC = checkOffset(Offset, 1)) 54 return EC; 55 Buffer = Data.drop_front(Offset); 56 return Error::success(); 57 } 58 59 uint32_t getLength() override { return Data.size(); } 60 61 Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> SrcData) override { 62 if (auto EC = checkOffset(Offset, SrcData.size())) 63 return EC; 64 ::memcpy(&Data[Offset], SrcData.data(), SrcData.size()); 65 return Error::success(); 66 } 67 Error commit() override { return Error::success(); } 68 69 MSFStreamLayout layout() const { 70 return MSFStreamLayout{static_cast<uint32_t>(Data.size()), Blocks}; 71 } 72 73 BumpPtrAllocator Allocator; 74 75 private: 76 std::vector<support::ulittle32_t> Blocks; 77 MutableArrayRef<uint8_t> Data; 78 }; 79 80 TEST(MappedBlockStreamTest, NumBlocks) { 81 DiscontiguousStream F(BlocksAry, DataAry); 82 auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F, 83 F.Allocator); 84 EXPECT_EQ(F.block_size(), S->getBlockSize()); 85 EXPECT_EQ(F.layout().Blocks.size(), S->getNumBlocks()); 86 } 87 88 // Tests that a read which is entirely contained within a single block works 89 // and does not allocate. 90 TEST(MappedBlockStreamTest, ReadBeyondEndOfStreamRef) { 91 DiscontiguousStream F(BlocksAry, DataAry); 92 auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F, 93 F.Allocator); 94 95 BinaryStreamReader R(*S); 96 BinaryStreamRef SR; 97 EXPECT_THAT_ERROR(R.readStreamRef(SR, 0U), Succeeded()); 98 ArrayRef<uint8_t> Buffer; 99 EXPECT_THAT_ERROR(SR.readBytes(0U, 1U, Buffer), Failed()); 100 EXPECT_THAT_ERROR(R.readStreamRef(SR, 1U), Succeeded()); 101 EXPECT_THAT_ERROR(SR.readBytes(1U, 1U, Buffer), Failed()); 102 } 103 104 // Tests that a read which outputs into a full destination buffer works and 105 // does not fail due to the length of the output buffer. 106 TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) { 107 DiscontiguousStream F(BlocksAry, DataAry); 108 auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F, 109 F.Allocator); 110 111 BinaryStreamReader R(*S); 112 StringRef Str = "ZYXWVUTSRQPONMLKJIHGFEDCBA"; 113 EXPECT_THAT_ERROR(R.readFixedString(Str, 1), Succeeded()); 114 EXPECT_EQ(Str, StringRef("A")); 115 EXPECT_EQ(0U, F.Allocator.getBytesAllocated()); 116 } 117 118 // Tests that a read which crosses a block boundary, but where the subsequent 119 // blocks are still contiguous in memory to the previous block works and does 120 // not allocate memory. 121 TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) { 122 DiscontiguousStream F(BlocksAry, DataAry); 123 auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F, 124 F.Allocator); 125 BinaryStreamReader R(*S); 126 StringRef Str; 127 EXPECT_THAT_ERROR(R.readFixedString(Str, 2), Succeeded()); 128 EXPECT_EQ(Str, StringRef("AB")); 129 EXPECT_EQ(0U, F.Allocator.getBytesAllocated()); 130 131 R.setOffset(6); 132 EXPECT_THAT_ERROR(R.readFixedString(Str, 4), Succeeded()); 133 EXPECT_EQ(Str, StringRef("GHIJ")); 134 EXPECT_EQ(0U, F.Allocator.getBytesAllocated()); 135 } 136 137 // Tests that a read which crosses a block boundary and cannot be referenced 138 // contiguously works and allocates only the precise amount of bytes 139 // requested. 140 TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) { 141 DiscontiguousStream F(BlocksAry, DataAry); 142 auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F, 143 F.Allocator); 144 BinaryStreamReader R(*S); 145 StringRef Str; 146 EXPECT_THAT_ERROR(R.readFixedString(Str, 10), Succeeded()); 147 EXPECT_EQ(Str, StringRef("ABCDEFGHIJ")); 148 EXPECT_EQ(10U, F.Allocator.getBytesAllocated()); 149 } 150 151 // Test that an out of bounds read which doesn't cross a block boundary 152 // fails and allocates no memory. 153 TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) { 154 DiscontiguousStream F(BlocksAry, DataAry); 155 auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F, 156 F.Allocator); 157 BinaryStreamReader R(*S); 158 StringRef Str; 159 160 R.setOffset(10); 161 EXPECT_THAT_ERROR(R.readFixedString(Str, 1), Failed()); 162 EXPECT_EQ(0U, F.Allocator.getBytesAllocated()); 163 } 164 165 // Test that an out of bounds read which crosses a contiguous block boundary 166 // fails and allocates no memory. 167 TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) { 168 DiscontiguousStream F(BlocksAry, DataAry); 169 auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F, 170 F.Allocator); 171 BinaryStreamReader R(*S); 172 StringRef Str; 173 174 R.setOffset(6); 175 EXPECT_THAT_ERROR(R.readFixedString(Str, 5), Failed()); 176 EXPECT_EQ(0U, F.Allocator.getBytesAllocated()); 177 } 178 179 // Test that an out of bounds read which crosses a discontiguous block 180 // boundary fails and allocates no memory. 181 TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) { 182 DiscontiguousStream F(BlocksAry, DataAry); 183 auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F, 184 F.Allocator); 185 BinaryStreamReader R(*S); 186 StringRef Str; 187 188 EXPECT_THAT_ERROR(R.readFixedString(Str, 11), Failed()); 189 EXPECT_EQ(0U, F.Allocator.getBytesAllocated()); 190 } 191 192 // Tests that a read which is entirely contained within a single block but 193 // beyond the end of a StreamRef fails. 194 TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) { 195 DiscontiguousStream F(BlocksAry, DataAry); 196 auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F, 197 F.Allocator); 198 BinaryStreamReader R(*S); 199 StringRef Str; 200 EXPECT_THAT_ERROR(R.readFixedString(Str, 1), Succeeded()); 201 EXPECT_EQ(Str, StringRef("A")); 202 EXPECT_EQ(0U, F.Allocator.getBytesAllocated()); 203 } 204 205 // Tests that a read which is not aligned on the same boundary as a previous 206 // cached request, but which is known to overlap that request, shares the 207 // previous allocation. 208 TEST(MappedBlockStreamTest, UnalignedOverlappingRead) { 209 DiscontiguousStream F(BlocksAry, DataAry); 210 auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F, 211 F.Allocator); 212 BinaryStreamReader R(*S); 213 StringRef Str1; 214 StringRef Str2; 215 EXPECT_THAT_ERROR(R.readFixedString(Str1, 7), Succeeded()); 216 EXPECT_EQ(Str1, StringRef("ABCDEFG")); 217 EXPECT_EQ(7U, F.Allocator.getBytesAllocated()); 218 219 R.setOffset(2); 220 EXPECT_THAT_ERROR(R.readFixedString(Str2, 3), Succeeded()); 221 EXPECT_EQ(Str2, StringRef("CDE")); 222 EXPECT_EQ(Str1.data() + 2, Str2.data()); 223 EXPECT_EQ(7U, F.Allocator.getBytesAllocated()); 224 } 225 226 // Tests that a read which is not aligned on the same boundary as a previous 227 // cached request, but which only partially overlaps a previous cached request, 228 // still works correctly and allocates again from the shared pool. 229 TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) { 230 DiscontiguousStream F(BlocksAry, DataAry); 231 auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F, 232 F.Allocator); 233 BinaryStreamReader R(*S); 234 StringRef Str1; 235 StringRef Str2; 236 EXPECT_THAT_ERROR(R.readFixedString(Str1, 6), Succeeded()); 237 EXPECT_EQ(Str1, StringRef("ABCDEF")); 238 EXPECT_EQ(6U, F.Allocator.getBytesAllocated()); 239 240 R.setOffset(4); 241 EXPECT_THAT_ERROR(R.readFixedString(Str2, 4), Succeeded()); 242 EXPECT_EQ(Str2, StringRef("EFGH")); 243 EXPECT_EQ(10U, F.Allocator.getBytesAllocated()); 244 } 245 246 TEST(MappedBlockStreamTest, WriteBeyondEndOfStream) { 247 static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'}; 248 static uint8_t LargeBuffer[] = {'0', '1', '2', '3', '4', '5', 249 '6', '7', '8', '9', 'A'}; 250 static uint8_t SmallBuffer[] = {'0', '1', '2'}; 251 static_assert(sizeof(LargeBuffer) > sizeof(Data), 252 "LargeBuffer is not big enough"); 253 254 DiscontiguousStream F(BlocksAry, Data); 255 auto S = WritableMappedBlockStream::createStream(F.block_size(), F.layout(), 256 F, F.Allocator); 257 ArrayRef<uint8_t> Buffer; 258 259 EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef<uint8_t>(LargeBuffer)), Failed()); 260 EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef<uint8_t>(SmallBuffer)), 261 Succeeded()); 262 EXPECT_THAT_ERROR(S->writeBytes(7, ArrayRef<uint8_t>(SmallBuffer)), 263 Succeeded()); 264 EXPECT_THAT_ERROR(S->writeBytes(8, ArrayRef<uint8_t>(SmallBuffer)), Failed()); 265 } 266 267 TEST(MappedBlockStreamTest, TestWriteBytesNoBreakBoundary) { 268 static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'}; 269 DiscontiguousStream F(BlocksAry, Data); 270 auto S = WritableMappedBlockStream::createStream(F.block_size(), F.layout(), 271 F, F.Allocator); 272 ArrayRef<uint8_t> Buffer; 273 274 EXPECT_THAT_ERROR(S->readBytes(0, 1, Buffer), Succeeded()); 275 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A')); 276 EXPECT_THAT_ERROR(S->readBytes(9, 1, Buffer), Succeeded()); 277 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J')); 278 279 EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef<uint8_t>('J')), Succeeded()); 280 EXPECT_THAT_ERROR(S->writeBytes(9, ArrayRef<uint8_t>('A')), Succeeded()); 281 282 EXPECT_THAT_ERROR(S->readBytes(0, 1, Buffer), Succeeded()); 283 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J')); 284 EXPECT_THAT_ERROR(S->readBytes(9, 1, Buffer), Succeeded()); 285 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A')); 286 287 EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef<uint8_t>('A')), Succeeded()); 288 EXPECT_THAT_ERROR(S->writeBytes(9, ArrayRef<uint8_t>('J')), Succeeded()); 289 290 EXPECT_THAT_ERROR(S->readBytes(0, 1, Buffer), Succeeded()); 291 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A')); 292 EXPECT_THAT_ERROR(S->readBytes(9, 1, Buffer), Succeeded()); 293 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J')); 294 } 295 296 TEST(MappedBlockStreamTest, TestWriteBytesBreakBoundary) { 297 static uint8_t Data[] = {'0', '0', '0', '0', '0', '0', '0', '0', '0', '0'}; 298 static uint8_t TestData[] = {'T', 'E', 'S', 'T', 'I', 'N', 'G', '.'}; 299 static uint8_t Expected[] = {'T', 'E', 'S', 'N', 'I', 300 'T', 'G', '.', '0', '0'}; 301 302 DiscontiguousStream F(BlocksAry, Data); 303 auto S = WritableMappedBlockStream::createStream(F.block_size(), F.layout(), 304 F, F.Allocator); 305 ArrayRef<uint8_t> Buffer; 306 307 EXPECT_THAT_ERROR(S->writeBytes(0, TestData), Succeeded()); 308 // First just compare the memory, then compare the result of reading the 309 // string out. 310 EXPECT_EQ(ArrayRef<uint8_t>(Data), ArrayRef<uint8_t>(Expected)); 311 312 EXPECT_THAT_ERROR(S->readBytes(0, 8, Buffer), Succeeded()); 313 EXPECT_EQ(Buffer, ArrayRef<uint8_t>(TestData)); 314 } 315 316 TEST(MappedBlockStreamTest, TestWriteThenRead) { 317 std::vector<uint8_t> DataBytes(10); 318 MutableArrayRef<uint8_t> Data(DataBytes); 319 const uint32_t Blocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8}; 320 321 DiscontiguousStream F(Blocks, Data); 322 auto S = WritableMappedBlockStream::createStream(F.block_size(), F.layout(), 323 F, F.Allocator); 324 325 enum class MyEnum : uint32_t { Val1 = 2908234, Val2 = 120891234 }; 326 using support::ulittle32_t; 327 328 uint16_t u16[] = {31468, 0}; 329 uint32_t u32[] = {890723408, 0}; 330 MyEnum Enum[] = {MyEnum::Val1, MyEnum::Val2}; 331 StringRef ZStr[] = {"Zero Str", ""}; 332 StringRef FStr[] = {"Fixed Str", ""}; 333 uint8_t byteArray0[] = {'1', '2'}; 334 uint8_t byteArray1[] = {'0', '0'}; 335 ArrayRef<uint8_t> byteArrayRef0(byteArray0); 336 ArrayRef<uint8_t> byteArrayRef1(byteArray1); 337 ArrayRef<uint8_t> byteArray[] = {byteArrayRef0, byteArrayRef1}; 338 uint32_t intArr0[] = {890723408, 29082234}; 339 uint32_t intArr1[] = {890723408, 29082234}; 340 ArrayRef<uint32_t> intArray[] = {intArr0, intArr1}; 341 342 BinaryStreamReader Reader(*S); 343 BinaryStreamWriter Writer(*S); 344 EXPECT_THAT_ERROR(Writer.writeInteger(u16[0]), Succeeded()); 345 EXPECT_THAT_ERROR(Reader.readInteger(u16[1]), Succeeded()); 346 EXPECT_EQ(u16[0], u16[1]); 347 EXPECT_EQ(std::vector<uint8_t>({0, 0x7A, 0xEC, 0, 0, 0, 0, 0, 0, 0}), 348 DataBytes); 349 350 Reader.setOffset(0); 351 Writer.setOffset(0); 352 ::memset(DataBytes.data(), 0, 10); 353 EXPECT_THAT_ERROR(Writer.writeInteger(u32[0]), Succeeded()); 354 EXPECT_THAT_ERROR(Reader.readInteger(u32[1]), Succeeded()); 355 EXPECT_EQ(u32[0], u32[1]); 356 EXPECT_EQ(std::vector<uint8_t>({0x17, 0x5C, 0x50, 0, 0, 0, 0x35, 0, 0, 0}), 357 DataBytes); 358 359 Reader.setOffset(0); 360 Writer.setOffset(0); 361 ::memset(DataBytes.data(), 0, 10); 362 EXPECT_THAT_ERROR(Writer.writeEnum(Enum[0]), Succeeded()); 363 EXPECT_THAT_ERROR(Reader.readEnum(Enum[1]), Succeeded()); 364 EXPECT_EQ(Enum[0], Enum[1]); 365 EXPECT_EQ(std::vector<uint8_t>({0x2C, 0x60, 0x4A, 0, 0, 0, 0, 0, 0, 0}), 366 DataBytes); 367 368 Reader.setOffset(0); 369 Writer.setOffset(0); 370 ::memset(DataBytes.data(), 0, 10); 371 EXPECT_THAT_ERROR(Writer.writeCString(ZStr[0]), Succeeded()); 372 EXPECT_THAT_ERROR(Reader.readCString(ZStr[1]), Succeeded()); 373 EXPECT_EQ(ZStr[0], ZStr[1]); 374 EXPECT_EQ( 375 std::vector<uint8_t>({'r', 'e', 'Z', ' ', 'S', 't', 'o', 'r', 0, 0}), 376 DataBytes); 377 378 Reader.setOffset(0); 379 Writer.setOffset(0); 380 ::memset(DataBytes.data(), 0, 10); 381 EXPECT_THAT_ERROR(Writer.writeFixedString(FStr[0]), Succeeded()); 382 EXPECT_THAT_ERROR(Reader.readFixedString(FStr[1], FStr[0].size()), 383 Succeeded()); 384 EXPECT_EQ(FStr[0], FStr[1]); 385 EXPECT_EQ( 386 std::vector<uint8_t>({'x', 'i', 'F', 'd', ' ', 'S', 'e', 't', 0, 'r'}), 387 DataBytes); 388 389 Reader.setOffset(0); 390 Writer.setOffset(0); 391 ::memset(DataBytes.data(), 0, 10); 392 EXPECT_THAT_ERROR(Writer.writeArray(byteArray[0]), Succeeded()); 393 EXPECT_THAT_ERROR(Reader.readArray(byteArray[1], byteArray[0].size()), 394 Succeeded()); 395 EXPECT_EQ(byteArray[0], byteArray[1]); 396 EXPECT_EQ(std::vector<uint8_t>({0, 0x32, 0x31, 0, 0, 0, 0, 0, 0, 0}), 397 DataBytes); 398 399 Reader.setOffset(0); 400 Writer.setOffset(0); 401 ::memset(DataBytes.data(), 0, 10); 402 EXPECT_THAT_ERROR(Writer.writeArray(intArray[0]), Succeeded()); 403 EXPECT_THAT_ERROR(Reader.readArray(intArray[1], intArray[0].size()), 404 Succeeded()); 405 EXPECT_EQ(intArray[0], intArray[1]); 406 } 407 408 TEST(MappedBlockStreamTest, TestWriteContiguousStreamRef) { 409 std::vector<uint8_t> DestDataBytes(10); 410 MutableArrayRef<uint8_t> DestData(DestDataBytes); 411 const uint32_t DestBlocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8}; 412 413 std::vector<uint8_t> SrcDataBytes(10); 414 MutableArrayRef<uint8_t> SrcData(SrcDataBytes); 415 416 DiscontiguousStream F(DestBlocks, DestData); 417 auto DestStream = WritableMappedBlockStream::createStream( 418 F.block_size(), F.layout(), F, F.Allocator); 419 420 // First write "Test Str" into the source stream. 421 MutableBinaryByteStream SourceStream(SrcData, little); 422 BinaryStreamWriter SourceWriter(SourceStream); 423 EXPECT_THAT_ERROR(SourceWriter.writeCString("Test Str"), Succeeded()); 424 EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>( 425 {'T', 'e', 's', 't', ' ', 'S', 't', 'r', 0, 0})); 426 427 // Then write the source stream into the dest stream. 428 BinaryStreamWriter DestWriter(*DestStream); 429 EXPECT_THAT_ERROR(DestWriter.writeStreamRef(SourceStream), Succeeded()); 430 EXPECT_EQ(DestDataBytes, std::vector<uint8_t>( 431 {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0})); 432 433 // Then read the string back out of the dest stream. 434 StringRef Result; 435 BinaryStreamReader DestReader(*DestStream); 436 EXPECT_THAT_ERROR(DestReader.readCString(Result), Succeeded()); 437 EXPECT_EQ(Result, "Test Str"); 438 } 439 440 TEST(MappedBlockStreamTest, TestWriteDiscontiguousStreamRef) { 441 std::vector<uint8_t> DestDataBytes(10); 442 MutableArrayRef<uint8_t> DestData(DestDataBytes); 443 const uint32_t DestBlocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8}; 444 445 std::vector<uint8_t> SrcDataBytes(10); 446 MutableArrayRef<uint8_t> SrcData(SrcDataBytes); 447 const uint32_t SrcBlocks[] = {1, 0, 6, 3, 4, 5, 2, 7, 8, 9}; 448 449 DiscontiguousStream DestF(DestBlocks, DestData); 450 DiscontiguousStream SrcF(SrcBlocks, SrcData); 451 452 auto Dest = WritableMappedBlockStream::createStream( 453 DestF.block_size(), DestF.layout(), DestF, DestF.Allocator); 454 auto Src = WritableMappedBlockStream::createStream( 455 SrcF.block_size(), SrcF.layout(), SrcF, SrcF.Allocator); 456 457 // First write "Test Str" into the source stream. 458 BinaryStreamWriter SourceWriter(*Src); 459 EXPECT_THAT_ERROR(SourceWriter.writeCString("Test Str"), Succeeded()); 460 EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>( 461 {'e', 'T', 't', 't', ' ', 'S', 's', 'r', 0, 0})); 462 463 // Then write the source stream into the dest stream. 464 BinaryStreamWriter DestWriter(*Dest); 465 EXPECT_THAT_ERROR(DestWriter.writeStreamRef(*Src), Succeeded()); 466 EXPECT_EQ(DestDataBytes, std::vector<uint8_t>( 467 {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0})); 468 469 // Then read the string back out of the dest stream. 470 StringRef Result; 471 BinaryStreamReader DestReader(*Dest); 472 EXPECT_THAT_ERROR(DestReader.readCString(Result), Succeeded()); 473 EXPECT_EQ(Result, "Test Str"); 474 } 475 476 TEST(MappedBlockStreamTest, DataLivesAfterStreamDestruction) { 477 std::vector<uint8_t> DataBytes(10); 478 MutableArrayRef<uint8_t> Data(DataBytes); 479 const uint32_t Blocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8}; 480 481 StringRef Str[] = {"Zero Str", ""}; 482 483 DiscontiguousStream F(Blocks, Data); 484 { 485 auto S = WritableMappedBlockStream::createStream(F.block_size(), F.layout(), 486 F, F.Allocator); 487 488 BinaryStreamReader Reader(*S); 489 BinaryStreamWriter Writer(*S); 490 ::memset(DataBytes.data(), 0, 10); 491 EXPECT_THAT_ERROR(Writer.writeCString(Str[0]), Succeeded()); 492 EXPECT_THAT_ERROR(Reader.readCString(Str[1]), Succeeded()); 493 EXPECT_EQ(Str[0], Str[1]); 494 } 495 496 EXPECT_EQ(Str[0], Str[1]); 497 } 498 } // namespace 499 500 MATCHER_P3(BlockIsFilledWith, Layout, BlockIndex, Byte, "succeeded") { 501 uint64_t Offset = msf::blockToOffset(BlockIndex, Layout.SB->BlockSize); 502 ArrayRef<uint8_t> BufferRef = makeArrayRef(arg); 503 BufferRef = BufferRef.slice(Offset, Layout.SB->BlockSize); 504 return llvm::all_of(BufferRef, [this](uint8_t B) { return B == Byte; }); 505 } 506 507 namespace { 508 TEST(MappedBlockStreamTest, CreateFpmStream) { 509 BumpPtrAllocator Allocator; 510 SuperBlock SB; 511 MSFLayout L; 512 L.SB = &SB; 513 514 SB.FreeBlockMapBlock = 1; 515 SB.BlockSize = 4096; 516 517 constexpr uint32_t NumFileBlocks = 4096 * 4; 518 519 std::vector<uint8_t> MsfBuffer(NumFileBlocks * SB.BlockSize); 520 MutableBinaryByteStream MsfStream(MsfBuffer, llvm::support::little); 521 522 SB.NumBlocks = NumFileBlocks; 523 auto FpmStream = 524 WritableMappedBlockStream::createFpmStream(L, MsfStream, Allocator); 525 // 4096 * 4 / 8 = 2048 bytes of FPM data is needed to describe 4096 * 4 526 // blocks. This translates to 1 FPM block. 527 EXPECT_EQ(2048u, FpmStream->getLength()); 528 EXPECT_EQ(1u, FpmStream->getStreamLayout().Blocks.size()); 529 EXPECT_EQ(1u, FpmStream->getStreamLayout().Blocks[0]); 530 // All blocks from FPM1 should be 1 initialized, and all blocks from FPM2 531 // should be 0 initialized (since we requested the main FPM, not the alt FPM) 532 for (int I = 0; I < 4; ++I) { 533 EXPECT_THAT(MsfBuffer, BlockIsFilledWith(L, 1 + I * SB.BlockSize, 0xFF)); 534 EXPECT_THAT(MsfBuffer, BlockIsFilledWith(L, 2 + I * SB.BlockSize, 0)); 535 } 536 537 ::memset(MsfBuffer.data(), 0, MsfBuffer.size()); 538 FpmStream = 539 WritableMappedBlockStream::createFpmStream(L, MsfStream, Allocator, true); 540 // 4096 * 4 / 8 = 2048 bytes of FPM data is needed to describe 4096 * 4 541 // blocks. This translates to 1 FPM block. 542 EXPECT_EQ(2048u, FpmStream->getLength()); 543 EXPECT_EQ(1u, FpmStream->getStreamLayout().Blocks.size()); 544 EXPECT_EQ(2u, FpmStream->getStreamLayout().Blocks[0]); 545 // All blocks from FPM2 should be 1 initialized, and all blocks from FPM1 546 // should be 0 initialized (since we requested the alt FPM, not the main FPM) 547 for (int I = 0; I < 4; ++I) { 548 EXPECT_THAT(MsfBuffer, BlockIsFilledWith(L, 1 + I * SB.BlockSize, 0)); 549 EXPECT_THAT(MsfBuffer, BlockIsFilledWith(L, 2 + I * SB.BlockSize, 0xFF)); 550 } 551 } 552 553 } // end anonymous namespace 554