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-exception
6 //
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
20 using namespace llvm;
21 using namespace llvm::msf;
22 using namespace llvm::support;
23
24 namespace {
25
26 static const uint32_t BlocksAry[] = {0, 1, 2, 5, 4, 3, 6, 7, 8, 9};
27 static uint8_t DataAry[] = {'A', 'B', 'C', 'F', 'E', 'D', 'G', 'H', 'I', 'J'};
28
29 class DiscontiguousStream : public WritableBinaryStream {
30 public:
DiscontiguousStream(ArrayRef<uint32_t> Blocks,MutableArrayRef<uint8_t> Data)31 DiscontiguousStream(ArrayRef<uint32_t> Blocks, MutableArrayRef<uint8_t> Data)
32 : Blocks(Blocks.begin(), Blocks.end()), Data(Data.begin(), Data.end()) {}
33
block_size() const34 uint32_t block_size() const { return 1; }
block_count() const35 uint32_t block_count() const { return Blocks.size(); }
36
getEndian() const37 llvm::endianness getEndian() const override {
38 return llvm::endianness::little;
39 }
40
readBytes(uint64_t Offset,uint64_t Size,ArrayRef<uint8_t> & Buffer)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
readLongestContiguousChunk(uint64_t Offset,ArrayRef<uint8_t> & Buffer)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
getLength()57 uint64_t getLength() override { return Data.size(); }
58
writeBytes(uint64_t Offset,ArrayRef<uint8_t> SrcData)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 }
commit()65 Error commit() override { return Error::success(); }
66
layout() const67 MSFStreamLayout layout() const {
68 return MSFStreamLayout{static_cast<uint32_t>(Data.size()), Blocks};
69 }
70
71 BumpPtrAllocator Allocator;
72
73 private:
74 std::vector<support::ulittle32_t> Blocks;
75 MutableArrayRef<uint8_t> Data;
76 };
77
TEST(MappedBlockStreamTest,NumBlocks)78 TEST(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 works
87 // and does not allocate.
TEST(MappedBlockStreamTest,ReadBeyondEndOfStreamRef)88 TEST(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 and
103 // does not fail due to the length of the output buffer.
TEST(MappedBlockStreamTest,ReadOntoNonEmptyBuffer)104 TEST(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 subsequent
117 // blocks are still contiguous in memory to the previous block works and does
118 // not allocate memory.
TEST(MappedBlockStreamTest,ZeroCopyReadContiguousBreak)119 TEST(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 referenced
136 // contiguously works and allocates only the precise amount of bytes
137 // requested.
TEST(MappedBlockStreamTest,CopyReadNonContiguousBreak)138 TEST(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 boundary
150 // fails and allocates no memory.
TEST(MappedBlockStreamTest,InvalidReadSizeNoBreak)151 TEST(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 boundary
164 // fails and allocates no memory.
TEST(MappedBlockStreamTest,InvalidReadSizeContiguousBreak)165 TEST(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 block
178 // boundary fails and allocates no memory.
TEST(MappedBlockStreamTest,InvalidReadSizeNonContiguousBreak)179 TEST(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 but
191 // beyond the end of a StreamRef fails.
TEST(MappedBlockStreamTest,ZeroCopyReadNoBreak)192 TEST(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 previous
204 // cached request, but which is known to overlap that request, shares the
205 // previous allocation.
TEST(MappedBlockStreamTest,UnalignedOverlappingRead)206 TEST(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 previous
225 // cached request, but which only partially overlaps a previous cached request,
226 // still works correctly and allocates again from the shared pool.
TEST(MappedBlockStreamTest,UnalignedOverlappingReadFail)227 TEST(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
TEST(MappedBlockStreamTest,WriteBeyondEndOfStream)244 TEST(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
TEST(MappedBlockStreamTest,TestWriteBytesNoBreakBoundary)263 TEST(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
TEST(MappedBlockStreamTest,TestWriteBytesBreakBoundary)292 TEST(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 the
305 // 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
TEST(MappedBlockStreamTest,TestWriteThenRead)312 TEST(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
TEST(MappedBlockStreamTest,TestWriteContiguousStreamRef)404 TEST(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
TEST(MappedBlockStreamTest,TestWriteDiscontiguousStreamRef)436 TEST(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
TEST(MappedBlockStreamTest,DataLivesAfterStreamDestruction)472 TEST(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 } // namespace
495
496 MATCHER_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);
__anon328fc6c40202(uint8_t B) 500 return llvm::all_of(BufferRef, [this](uint8_t B) { return B == Byte; });
501 }
502
503 namespace {
TEST(MappedBlockStreamTest,CreateFpmStream)504 TEST(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 * 4
522 // 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 FPM2
527 // 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 * 4
537 // 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 FPM1
542 // 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 namespace
550