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