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