unittests/Support/MemoryBufferTest.cpp

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