| 1 |
//===- llvm/unittest/Support/MemoryBufferTest.cpp - MemoryBuffer tests ----===// |
| 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 |
// This file implements unit tests for the MemoryBuffer support class. |
| 10 |
// |
| 11 |
//===----------------------------------------------------------------------===// |
| 12 |
|
| 13 |
#include "llvm/Support/MemoryBuffer.h" |
| 14 |
#include "llvm/Support/SmallVectorMemoryBuffer.h" |
| 15 |
#include "llvm/ADT/ScopeExit.h" |
| 16 |
#include "llvm/Support/FileSystem.h" |
| 17 |
#include "llvm/Support/FileUtilities.h" |
| 18 |
#include "llvm/Support/Process.h" |
| 19 |
#include "llvm/Support/raw_ostream.h" |
| 20 |
#include "llvm/Testing/Support/Error.h" |
| 21 |
#include "gtest/gtest.h" |
| 22 |
#if LLVM_ENABLE_THREADS |
| 23 |
#include <thread> |
| 24 |
#endif |
| 25 |
#if LLVM_ON_UNIX |
| 26 |
#include <unistd.h> |
| 27 |
#endif |
| 28 |
#if _WIN32 |
| 29 |
#include <windows.h> |
| 30 |
#endif |
| 31 |
|
| 32 |
using namespace llvm; |
| 33 |
|
| 34 |
#define ASSERT_NO_ERROR(x) \ |
| 35 |
if (std::error_code ASSERT_NO_ERROR_ec = x) { \ |
| 36 |
SmallString<128> MessageStorage; \ |
| 37 |
raw_svector_ostream Message(MessageStorage); \ |
| 38 |
Message << #x ": did not return errc::success.\n" \ |
| 39 |
<< "error number: " << ASSERT_NO_ERROR_ec.value() << "\n" \ |
| 40 |
<< "error message: " << ASSERT_NO_ERROR_ec.message() << "\n"; \ |
| 41 |
GTEST_FATAL_FAILURE_(MessageStorage.c_str()); \ |
| 42 |
} else { \ |
| 43 |
} |
| 44 |
|
| 45 |
#define ASSERT_ERROR(x) \ |
| 46 |
if (!x) { \ |
| 47 |
SmallString<128> MessageStorage; \ |
| 48 |
raw_svector_ostream Message(MessageStorage); \ |
| 49 |
Message << #x ": did not return a failure error code.\n"; \ |
| 50 |
GTEST_FATAL_FAILURE_(MessageStorage.c_str()); \ |
| 51 |
} |
| 52 |
|
| 53 |
namespace { |
| 54 |
|
| 55 |
class MemoryBufferTest : public testing::Test { |
| 56 |
protected: |
| 57 |
MemoryBufferTest() |
| 58 |
: data("this is some data") |
| 59 |
{ } |
| 60 |
|
| 61 |
void SetUp() override {} |
| 62 |
|
| 63 |
/// Common testing for different modes of getOpenFileSlice. |
| 64 |
/// Creates a temporary file with known contents, and uses |
| 65 |
/// MemoryBuffer::getOpenFileSlice to map it. |
| 66 |
/// If \p Reopen is true, the file is closed after creating and reopened |
| 67 |
/// anew before using MemoryBuffer. |
| 68 |
void testGetOpenFileSlice(bool Reopen); |
| 69 |
|
| 70 |
typedef std::unique_ptr<MemoryBuffer> OwningBuffer; |
| 71 |
|
| 72 |
std::string data; |
| 73 |
}; |
| 74 |
|
| 75 |
TEST_F(MemoryBufferTest, get) { |
| 76 |
// Default name and null-terminator flag |
| 77 |
OwningBuffer MB1(MemoryBuffer::getMemBuffer(data)); |
| 78 |
EXPECT_NE(nullptr, MB1.get()); |
| 79 |
|
| 80 |
// RequiresNullTerminator = false |
| 81 |
OwningBuffer MB2(MemoryBuffer::getMemBuffer(data, "one", false)); |
| 82 |
EXPECT_NE(nullptr, MB2.get()); |
| 83 |
|
| 84 |
// RequiresNullTerminator = true |
| 85 |
OwningBuffer MB3(MemoryBuffer::getMemBuffer(data, "two", true)); |
| 86 |
EXPECT_NE(nullptr, MB3.get()); |
| 87 |
|
| 88 |
// verify all 3 buffers point to the same address |
| 89 |
EXPECT_EQ(MB1->getBufferStart(), MB2->getBufferStart()); |
| 90 |
EXPECT_EQ(MB2->getBufferStart(), MB3->getBufferStart()); |
| 91 |
|
| 92 |
// verify the original data is unmodified after deleting the buffers |
| 93 |
MB1.reset(); |
| 94 |
MB2.reset(); |
| 95 |
MB3.reset(); |
| 96 |
EXPECT_EQ("this is some data", data); |
| 97 |
} |
| 98 |
|
| 99 |
TEST_F(MemoryBufferTest, getOpenFile) { |
| 100 |
int FD; |
| 101 |
SmallString<64> TestPath; |
| 102 |
ASSERT_EQ(sys::fs::createTemporaryFile("MemoryBufferTest_getOpenFile", "temp", |
| 103 |
FD, TestPath), |
| 104 |
std::error_code()); |
| 105 |
|
| 106 |
FileRemover Cleanup(TestPath); |
| 107 |
raw_fd_ostream OF(FD, /*shouldClose*/ true); |
| 108 |
OF << "12345678"; |
| 109 |
OF.close(); |
| 110 |
|
| 111 |
{ |
| 112 |
Expected<sys::fs::file_t> File = sys::fs::openNativeFileForRead(TestPath); |
| 113 |
ASSERT_THAT_EXPECTED(File, Succeeded()); |
| 114 |
auto OnExit = |
| 115 |
make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); }); |
| 116 |
ErrorOr<OwningBuffer> MB = MemoryBuffer::getOpenFile(*File, TestPath, 6); |
| 117 |
ASSERT_NO_ERROR(MB.getError()); |
| 118 |
EXPECT_EQ("123456", MB.get()->getBuffer()); |
| 119 |
} |
| 120 |
{ |
| 121 |
Expected<sys::fs::file_t> File = sys::fs::openNativeFileForWrite( |
| 122 |
TestPath, sys::fs::CD_OpenExisting, sys::fs::OF_None); |
| 123 |
ASSERT_THAT_EXPECTED(File, Succeeded()); |
| 124 |
auto OnExit = |
| 125 |
make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); }); |
| 126 |
ASSERT_ERROR(MemoryBuffer::getOpenFile(*File, TestPath, 6).getError()); |
| 127 |
} |
| 128 |
} |
| 129 |
|
| 130 |
TEST_F(MemoryBufferTest, NullTerminator4K) { |
| 131 |
// Test that a file with size that is a multiple of the page size can be null |
| 132 |
// terminated correctly by MemoryBuffer. |
| 133 |
int TestFD; |
| 134 |
SmallString<64> TestPath; |
| 135 |
sys::fs::createTemporaryFile("MemoryBufferTest_NullTerminator4K", "temp", |
| 136 |
TestFD, TestPath); |
| 137 |
FileRemover Cleanup(TestPath); |
| 138 |
raw_fd_ostream OF(TestFD, true, /*unbuffered=*/true); |
| 139 |
for (unsigned i = 0; i < 4096 / 16; ++i) { |
| 140 |
OF << "0123456789abcdef"; |
| 141 |
} |
| 142 |
OF.close(); |
| 143 |
|
| 144 |
ErrorOr<OwningBuffer> MB = MemoryBuffer::getFile(TestPath.c_str()); |
| 145 |
std::error_code EC = MB.getError(); |
| 146 |
ASSERT_FALSE(EC); |
| 147 |
|
| 148 |
const char *BufData = MB.get()->getBufferStart(); |
| 149 |
EXPECT_EQ('f', BufData[4095]); |
| 150 |
EXPECT_EQ('\0', BufData[4096]); |
| 151 |
} |
| 152 |
|
| 153 |
TEST_F(MemoryBufferTest, copy) { |
| 154 |
// copy with no name |
| 155 |
OwningBuffer MBC1(MemoryBuffer::getMemBufferCopy(data)); |
| 156 |
EXPECT_NE(nullptr, MBC1.get()); |
| 157 |
|
| 158 |
// copy with a name |
| 159 |
OwningBuffer MBC2(MemoryBuffer::getMemBufferCopy(data, "copy")); |
| 160 |
EXPECT_NE(nullptr, MBC2.get()); |
| 161 |
|
| 162 |
// verify the two copies do not point to the same place |
| 163 |
EXPECT_NE(MBC1->getBufferStart(), MBC2->getBufferStart()); |
| 164 |
} |
| 165 |
|
| 166 |
#if LLVM_ENABLE_THREADS |
| 167 |
TEST_F(MemoryBufferTest, createFromPipe) { |
| 168 |
sys::fs::file_t pipes[2]; |
| 169 |
#if LLVM_ON_UNIX |
| 170 |
ASSERT_EQ(::pipe(pipes), 0) << strerror(errno); |
| 171 |
#else |
| 172 |
ASSERT_TRUE(::CreatePipe(&pipes[0], &pipes[1], nullptr, 0)) |
| 173 |
<< ::GetLastError(); |
| 174 |
#endif |
| 175 |
auto ReadCloser = make_scope_exit([&] { sys::fs::closeFile(pipes[0]); }); |
| 176 |
std::thread Writer([&] { |
| 177 |
auto WriteCloser = make_scope_exit([&] { sys::fs::closeFile(pipes[1]); }); |
| 178 |
for (unsigned i = 0; i < 5; ++i) { |
| 179 |
std::this_thread::sleep_for(std::chrono::milliseconds(10)); |
| 180 |
#if LLVM_ON_UNIX |
| 181 |
ASSERT_EQ(::write(pipes[1], "foo", 3), 3) << strerror(errno); |
| 182 |
#else |
| 183 |
DWORD Written; |
| 184 |
ASSERT_TRUE(::WriteFile(pipes[1], "foo", 3, &Written, nullptr)) |
| 185 |
<< ::GetLastError(); |
| 186 |
ASSERT_EQ(Written, 3u); |
| 187 |
#endif |
| 188 |
} |
| 189 |
}); |
| 190 |
ErrorOr<OwningBuffer> MB = |
| 191 |
MemoryBuffer::getOpenFile(pipes[0], "pipe", /*FileSize*/ -1); |
| 192 |
Writer.join(); |
| 193 |
ASSERT_NO_ERROR(MB.getError()); |
| 194 |
EXPECT_EQ(MB.get()->getBuffer(), "foofoofoofoofoo"); |
| 195 |
} |
| 196 |
#endif |
| 197 |
|
| 198 |
TEST_F(MemoryBufferTest, make_new) { |
| 199 |
// 0-sized buffer |
| 200 |
OwningBuffer Zero(WritableMemoryBuffer::getNewUninitMemBuffer(0)); |
| 201 |
EXPECT_NE(nullptr, Zero.get()); |
| 202 |
|
| 203 |
// uninitialized buffer with no name |
| 204 |
OwningBuffer One(WritableMemoryBuffer::getNewUninitMemBuffer(321)); |
| 205 |
EXPECT_NE(nullptr, One.get()); |
| 206 |
|
| 207 |
// uninitialized buffer with name |
| 208 |
OwningBuffer Two(WritableMemoryBuffer::getNewUninitMemBuffer(123, "bla")); |
| 209 |
EXPECT_NE(nullptr, Two.get()); |
| 210 |
|
| 211 |
// 0-initialized buffer with no name |
| 212 |
OwningBuffer Three(WritableMemoryBuffer::getNewMemBuffer(321, data)); |
| 213 |
EXPECT_NE(nullptr, Three.get()); |
| 214 |
for (size_t i = 0; i < 321; ++i) |
| 215 |
EXPECT_EQ(0, Three->getBufferStart()[0]); |
| 216 |
|
| 217 |
// 0-initialized buffer with name |
| 218 |
OwningBuffer Four(WritableMemoryBuffer::getNewMemBuffer(123, "zeros")); |
| 219 |
EXPECT_NE(nullptr, Four.get()); |
| 220 |
for (size_t i = 0; i < 123; ++i) |
| 221 |
EXPECT_EQ(0, Four->getBufferStart()[0]); |
| 222 |
|
| 223 |
// uninitialized buffer with rollover size |
| 224 |
OwningBuffer Five( |
| 225 |
WritableMemoryBuffer::getNewUninitMemBuffer(SIZE_MAX, "huge")); |
| 226 |
EXPECT_EQ(nullptr, Five.get()); |
| 227 |
} |
| 228 |
|
| 229 |
TEST_F(MemoryBufferTest, getNewAligned) { |
| 230 |
auto CheckAlignment = [](size_t AlignmentValue) { |
| 231 |
Align Alignment(AlignmentValue); |
| 232 |
OwningBuffer AlignedBuffer = |
| 233 |
WritableMemoryBuffer::getNewUninitMemBuffer(0, "", Alignment); |
| 234 |
EXPECT_TRUE(isAddrAligned(Alignment, AlignedBuffer->getBufferStart())); |
| 235 |
}; |
| 236 |
|
| 237 |
// Test allocation with different alignments. |
| 238 |
CheckAlignment(16); |
| 239 |
CheckAlignment(32); |
| 240 |
CheckAlignment(64); |
| 241 |
CheckAlignment(128); |
| 242 |
CheckAlignment(256); |
| 243 |
} |
| 244 |
|
| 245 |
void MemoryBufferTest::testGetOpenFileSlice(bool Reopen) { |
| 246 |
// Test that MemoryBuffer::getOpenFile works properly when no null |
| 247 |
// terminator is requested and the size is large enough to trigger |
| 248 |
// the usage of memory mapping. |
| 249 |
int TestFD; |
| 250 |
SmallString<64> TestPath; |
| 251 |
// Create a temporary file and write data into it. |
| 252 |
sys::fs::createTemporaryFile("prefix", "temp", TestFD, TestPath); |
| 253 |
FileRemover Cleanup(TestPath); |
| 254 |
// OF is responsible for closing the file; If the file is not |
| 255 |
// reopened, it will be unbuffered so that the results are |
| 256 |
// immediately visible through the fd. |
| 257 |
raw_fd_ostream OF(TestFD, true, !Reopen); |
| 258 |
for (int i = 0; i < 60000; ++i) { |
| 259 |
OF << "0123456789"; |
| 260 |
} |
| 261 |
|
| 262 |
if (Reopen) { |
| 263 |
OF.close(); |
| 264 |
EXPECT_FALSE(sys::fs::openFileForRead(TestPath.c_str(), TestFD)); |
| 265 |
} |
| 266 |
|
| 267 |
ErrorOr<OwningBuffer> Buf = MemoryBuffer::getOpenFileSlice( |
| 268 |
sys::fs::convertFDToNativeFile(TestFD), TestPath.c_str(), |
| 269 |
40000, // Size |
| 270 |
80000 // Offset |
| 271 |
); |
| 272 |
|
| 273 |
std::error_code EC = Buf.getError(); |
| 274 |
EXPECT_FALSE(EC); |
| 275 |
|
| 276 |
StringRef BufData = Buf.get()->getBuffer(); |
| 277 |
EXPECT_EQ(BufData.size(), 40000U); |
| 278 |
EXPECT_EQ(BufData[0], '0'); |
| 279 |
EXPECT_EQ(BufData[9], '9'); |
| 280 |
} |
| 281 |
|
| 282 |
TEST_F(MemoryBufferTest, getOpenFileNoReopen) { |
| 283 |
testGetOpenFileSlice(false); |
| 284 |
} |
| 285 |
|
| 286 |
TEST_F(MemoryBufferTest, getOpenFileReopened) { |
| 287 |
testGetOpenFileSlice(true); |
| 288 |
} |
| 289 |
|
| 290 |
TEST_F(MemoryBufferTest, slice) { |
| 291 |
// Create a file that is six pages long with different data on each page. |
| 292 |
int FD; |
| 293 |
SmallString<64> TestPath; |
| 294 |
sys::fs::createTemporaryFile("MemoryBufferTest_Slice", "temp", FD, TestPath); |
| 295 |
FileRemover Cleanup(TestPath); |
| 296 |
raw_fd_ostream OF(FD, true, /*unbuffered=*/true); |
| 297 |
for (unsigned i = 0; i < 0x2000 / 8; ++i) { |
| 298 |
OF << "12345678"; |
| 299 |
} |
| 300 |
for (unsigned i = 0; i < 0x2000 / 8; ++i) { |
| 301 |
OF << "abcdefgh"; |
| 302 |
} |
| 303 |
for (unsigned i = 0; i < 0x2000 / 8; ++i) { |
| 304 |
OF << "ABCDEFGH"; |
| 305 |
} |
| 306 |
OF.close(); |
| 307 |
|
| 308 |
// Try offset of one page. |
| 309 |
ErrorOr<OwningBuffer> MB = MemoryBuffer::getFileSlice(TestPath.str(), |
| 310 |
0x4000, 0x1000); |
| 311 |
std::error_code EC = MB.getError(); |
| 312 |
ASSERT_FALSE(EC); |
| 313 |
EXPECT_EQ(0x4000UL, MB.get()->getBufferSize()); |
| 314 |
|
| 315 |
StringRef BufData = MB.get()->getBuffer(); |
| 316 |
EXPECT_TRUE(BufData.substr(0x0000,8).equals("12345678")); |
| 317 |
EXPECT_TRUE(BufData.substr(0x0FF8,8).equals("12345678")); |
| 318 |
EXPECT_TRUE(BufData.substr(0x1000,8).equals("abcdefgh")); |
| 319 |
EXPECT_TRUE(BufData.substr(0x2FF8,8).equals("abcdefgh")); |
| 320 |
EXPECT_TRUE(BufData.substr(0x3000,8).equals("ABCDEFGH")); |
| 321 |
EXPECT_TRUE(BufData.substr(0x3FF8,8).equals("ABCDEFGH")); |
| 322 |
|
| 323 |
// Try non-page aligned. |
| 324 |
ErrorOr<OwningBuffer> MB2 = MemoryBuffer::getFileSlice(TestPath.str(), |
| 325 |
0x3000, 0x0800); |
| 326 |
EC = MB2.getError(); |
| 327 |
ASSERT_FALSE(EC); |
| 328 |
EXPECT_EQ(0x3000UL, MB2.get()->getBufferSize()); |
| 329 |
|
| 330 |
StringRef BufData2 = MB2.get()->getBuffer(); |
| 331 |
EXPECT_TRUE(BufData2.substr(0x0000,8).equals("12345678")); |
| 332 |
EXPECT_TRUE(BufData2.substr(0x17F8,8).equals("12345678")); |
| 333 |
EXPECT_TRUE(BufData2.substr(0x1800,8).equals("abcdefgh")); |
| 334 |
EXPECT_TRUE(BufData2.substr(0x2FF8,8).equals("abcdefgh")); |
| 335 |
} |
| 336 |
|
| 337 |
TEST_F(MemoryBufferTest, writableSlice) { |
| 338 |
// Create a file initialized with some data |
| 339 |
int FD; |
| 340 |
SmallString<64> TestPath; |
| 341 |
sys::fs::createTemporaryFile("MemoryBufferTest_WritableSlice", "temp", FD, |
| 342 |
TestPath); |
| 343 |
FileRemover Cleanup(TestPath); |
| 344 |
raw_fd_ostream OF(FD, true); |
| 345 |
for (unsigned i = 0; i < 0x1000; ++i) |
| 346 |
OF << "0123456789abcdef"; |
| 347 |
OF.close(); |
| 348 |
|
| 349 |
{ |
| 350 |
auto MBOrError = |
| 351 |
WritableMemoryBuffer::getFileSlice(TestPath.str(), 0x6000, 0x2000); |
| 352 |
ASSERT_FALSE(MBOrError.getError()); |
| 353 |
// Write some data. It should be mapped private, so that upon completion |
| 354 |
// the original file contents are not modified. |
| 355 |
WritableMemoryBuffer &MB = **MBOrError; |
| 356 |
ASSERT_EQ(0x6000u, MB.getBufferSize()); |
| 357 |
char *Start = MB.getBufferStart(); |
| 358 |
ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize()); |
| 359 |
::memset(Start, 'x', MB.getBufferSize()); |
| 360 |
} |
| 361 |
|
| 362 |
auto MBOrError = MemoryBuffer::getFile(TestPath); |
| 363 |
ASSERT_FALSE(MBOrError.getError()); |
| 364 |
auto &MB = **MBOrError; |
| 365 |
ASSERT_EQ(0x10000u, MB.getBufferSize()); |
| 366 |
for (size_t i = 0; i < MB.getBufferSize(); i += 0x10) |
| 367 |
EXPECT_EQ("0123456789abcdef", MB.getBuffer().substr(i, 0x10)) << "i: " << i; |
| 368 |
} |
| 369 |
|
| 370 |
TEST_F(MemoryBufferTest, writeThroughFile) { |
| 371 |
// Create a file initialized with some data |
| 372 |
int FD; |
| 373 |
SmallString<64> TestPath; |
| 374 |
sys::fs::createTemporaryFile("MemoryBufferTest_WriteThrough", "temp", FD, |
| 375 |
TestPath); |
| 376 |
FileRemover Cleanup(TestPath); |
| 377 |
raw_fd_ostream OF(FD, true); |
| 378 |
OF << "0123456789abcdef"; |
| 379 |
OF.close(); |
| 380 |
{ |
| 381 |
auto MBOrError = WriteThroughMemoryBuffer::getFile(TestPath); |
| 382 |
ASSERT_FALSE(MBOrError.getError()); |
| 383 |
// Write some data. It should be mapped readwrite, so that upon completion |
| 384 |
// the original file contents are modified. |
| 385 |
WriteThroughMemoryBuffer &MB = **MBOrError; |
| 386 |
ASSERT_EQ(16u, MB.getBufferSize()); |
| 387 |
char *Start = MB.getBufferStart(); |
| 388 |
ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize()); |
| 389 |
::memset(Start, 'x', MB.getBufferSize()); |
| 390 |
} |
| 391 |
|
| 392 |
auto MBOrError = MemoryBuffer::getFile(TestPath); |
| 393 |
ASSERT_FALSE(MBOrError.getError()); |
| 394 |
auto &MB = **MBOrError; |
| 395 |
ASSERT_EQ(16u, MB.getBufferSize()); |
| 396 |
EXPECT_EQ("xxxxxxxxxxxxxxxx", MB.getBuffer()); |
| 397 |
} |
| 398 |
|
| 399 |
TEST_F(MemoryBufferTest, mmapVolatileNoNull) { |
| 400 |
// Verify that `MemoryBuffer::getOpenFile` will use mmap when |
| 401 |
// `RequiresNullTerminator = false`, `IsVolatile = true`, and the file is |
| 402 |
// large enough to use mmap. |
| 403 |
// |
| 404 |
// This is done because Clang should use this mode to open module files, and |
| 405 |
// falling back to malloc for them causes a huge memory usage increase. |
| 406 |
|
| 407 |
int FD; |
| 408 |
SmallString<64> TestPath; |
| 409 |
ASSERT_NO_ERROR(sys::fs::createTemporaryFile( |
| 410 |
"MemoryBufferTest_mmapVolatileNoNull", "temp", FD, TestPath)); |
| 411 |
FileRemover Cleanup(TestPath); |
| 412 |
raw_fd_ostream OF(FD, true); |
| 413 |
// Create a file large enough to mmap. 4 pages should be enough. |
| 414 |
unsigned PageSize = sys::Process::getPageSizeEstimate(); |
| 415 |
unsigned FileWrites = (PageSize * 4) / 8; |
| 416 |
for (unsigned i = 0; i < FileWrites; ++i) |
| 417 |
OF << "01234567"; |
| 418 |
OF.close(); |
| 419 |
|
| 420 |
Expected<sys::fs::file_t> File = sys::fs::openNativeFileForRead(TestPath); |
| 421 |
ASSERT_THAT_EXPECTED(File, Succeeded()); |
| 422 |
auto OnExit = |
| 423 |
make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); }); |
| 424 |
|
| 425 |
auto MBOrError = MemoryBuffer::getOpenFile(*File, TestPath, |
| 426 |
/*FileSize=*/-1, /*RequiresNullTerminator=*/false, /*IsVolatile=*/true); |
| 427 |
ASSERT_NO_ERROR(MBOrError.getError()) |
| 428 |
OwningBuffer MB = std::move(*MBOrError); |
| 429 |
EXPECT_EQ(MB->getBufferKind(), MemoryBuffer::MemoryBuffer_MMap); |
| 430 |
EXPECT_EQ(MB->getBufferSize(), std::size_t(FileWrites * 8)); |
| 431 |
EXPECT_TRUE(MB->getBuffer().startswith("01234567")); |
| 432 |
} |
| 433 |
|
| 434 |
// Test that SmallVector without a null terminator gets one. |
| 435 |
TEST(SmallVectorMemoryBufferTest, WithoutNullTerminatorRequiresNullTerminator) { |
| 436 |
SmallString<0> Data("some data"); |
| 437 |
|
| 438 |
SmallVectorMemoryBuffer MB(std::move(Data), |
| 439 |
/*RequiresNullTerminator=*/true); |
| 440 |
EXPECT_EQ(MB.getBufferSize(), 9u); |
| 441 |
EXPECT_EQ(MB.getBufferEnd()[0], '\0'); |
| 442 |
} |
| 443 |
|
| 444 |
// Test that SmallVector with a null terminator keeps it. |
| 445 |
TEST(SmallVectorMemoryBufferTest, WithNullTerminatorRequiresNullTerminator) { |
| 446 |
SmallString<0> Data("some data"); |
| 447 |
Data.push_back('\0'); |
| 448 |
Data.pop_back(); |
| 449 |
|
| 450 |
SmallVectorMemoryBuffer MB(std::move(Data), |
| 451 |
/*RequiresNullTerminator=*/true); |
| 452 |
EXPECT_EQ(MB.getBufferSize(), 9u); |
| 453 |
EXPECT_EQ(MB.getBufferEnd()[0], '\0'); |
| 454 |
} |
| 455 |
|
| 456 |
} // namespace |