unittests/Support/MemoryBufferTest.cpp

   1 //===- llvm/unittest/Support/MemoryBufferTest.cpp - MemoryBuffer tests ----===//
   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 // This file implements unit tests for the MemoryBuffer support class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Support/FileSystem.h"
  15 #include "llvm/Support/MemoryBuffer.h"
  16 #include "llvm/Support/raw_ostream.h"
  17 #include "gtest/gtest.h"
  18
  19 using namespace llvm;
  20
  21 namespace {
  22
  23 class MemoryBufferTest : public testing::Test {
  24 protected:
  25   MemoryBufferTest()
  26   : data("this is some data")
  27   { }
  28
  29   void SetUp() override {}
  30
  31   /// Common testing for different modes of getOpenFileSlice.
  32   /// Creates a temporary file with known contents, and uses
  33   /// MemoryBuffer::getOpenFileSlice to map it.
  34   /// If \p Reopen is true, the file is closed after creating and reopened
  35   /// anew before using MemoryBuffer.
  36   void testGetOpenFileSlice(bool Reopen);
  37
  38   typedef std::unique_ptr<MemoryBuffer> OwningBuffer;
  39
  40   std::string data;
  41 };
  42
  43 TEST_F(MemoryBufferTest, get) {
  44   // Default name and null-terminator flag
  45   OwningBuffer MB1(MemoryBuffer::getMemBuffer(data));
  46   EXPECT_TRUE(nullptr != MB1.get());
  47
  48   // RequiresNullTerminator = false
  49   OwningBuffer MB2(MemoryBuffer::getMemBuffer(data, "one", false));
  50   EXPECT_TRUE(nullptr != MB2.get());
  51
  52   // RequiresNullTerminator = true
  53   OwningBuffer MB3(MemoryBuffer::getMemBuffer(data, "two", true));
  54   EXPECT_TRUE(nullptr != MB3.get());
  55
  56   // verify all 3 buffers point to the same address
  57   EXPECT_EQ(MB1->getBufferStart(), MB2->getBufferStart());
  58   EXPECT_EQ(MB2->getBufferStart(), MB3->getBufferStart());
  59
  60   // verify the original data is unmodified after deleting the buffers
  61   MB1.reset();
  62   MB2.reset();
  63   MB3.reset();
  64   EXPECT_EQ("this is some data", data);
  65 }
  66
  67 TEST_F(MemoryBufferTest, NullTerminator4K) {
  68   // Test that a file with size that is a multiple of the page size can be null
  69   // terminated correctly by MemoryBuffer.
  70   int TestFD;
  71   SmallString<64> TestPath;
  72   sys::fs::createTemporaryFile("MemoryBufferTest_NullTerminator4K", "temp",
  73                                TestFD, TestPath);
  74   raw_fd_ostream OF(TestFD, true, /*unbuffered=*/true);
  75   for (unsigned i = 0; i < 4096 / 16; ++i) {
  76     OF << "0123456789abcdef";
  77   }
  78   OF.close();
  79
  80   ErrorOr<OwningBuffer> MB = MemoryBuffer::getFile(TestPath.c_str());
  81   std::error_code EC = MB.getError();
  82   ASSERT_FALSE(EC);
  83
  84   const char *BufData = MB.get()->getBufferStart();
  85   EXPECT_EQ('f', BufData[4095]);
  86   EXPECT_EQ('\0', BufData[4096]);
  87 }
  88
  89 TEST_F(MemoryBufferTest, copy) {
  90   // copy with no name
  91   OwningBuffer MBC1(MemoryBuffer::getMemBufferCopy(data));
  92   EXPECT_TRUE(nullptr != MBC1.get());
  93
  94   // copy with a name
  95   OwningBuffer MBC2(MemoryBuffer::getMemBufferCopy(data, "copy"));
  96   EXPECT_TRUE(nullptr != MBC2.get());
  97
  98   // verify the two copies do not point to the same place
  99   EXPECT_NE(MBC1->getBufferStart(), MBC2->getBufferStart());
 100 }
 101
 102 TEST_F(MemoryBufferTest, make_new) {
 103   // 0-sized buffer
 104   OwningBuffer Zero(MemoryBuffer::getNewUninitMemBuffer(0));
 105   EXPECT_TRUE(nullptr != Zero.get());
 106
 107   // uninitialized buffer with no name
 108   OwningBuffer One(MemoryBuffer::getNewUninitMemBuffer(321));
 109   EXPECT_TRUE(nullptr != One.get());
 110
 111   // uninitialized buffer with name
 112   OwningBuffer Two(MemoryBuffer::getNewUninitMemBuffer(123, "bla"));
 113   EXPECT_TRUE(nullptr != Two.get());
 114
 115   // 0-initialized buffer with no name
 116   OwningBuffer Three(MemoryBuffer::getNewMemBuffer(321, data));
 117   EXPECT_TRUE(nullptr != Three.get());
 118   for (size_t i = 0; i < 321; ++i)
 119     EXPECT_EQ(0, Three->getBufferStart()[0]);
 120
 121   // 0-initialized buffer with name
 122   OwningBuffer Four(MemoryBuffer::getNewMemBuffer(123, "zeros"));
 123   EXPECT_TRUE(nullptr != Four.get());
 124   for (size_t i = 0; i < 123; ++i)
 125     EXPECT_EQ(0, Four->getBufferStart()[0]);
 126 }
 127
 128 void MemoryBufferTest::testGetOpenFileSlice(bool Reopen) {
 129   // Test that MemoryBuffer::getOpenFile works properly when no null
 130   // terminator is requested and the size is large enough to trigger
 131   // the usage of memory mapping.
 132   int TestFD;
 133   SmallString<64> TestPath;
 134   // Create a temporary file and write data into it.
 135   sys::fs::createTemporaryFile("prefix", "temp", TestFD, TestPath);
 136   // OF is responsible for closing the file; If the file is not
 137   // reopened, it will be unbuffered so that the results are
 138   // immediately visible through the fd.
 139   raw_fd_ostream OF(TestFD, true, !Reopen);
 140   for (int i = 0; i < 60000; ++i) {
 141     OF << "0123456789";
 142   }
 143
 144   if (Reopen) {
 145     OF.close();
 146     EXPECT_FALSE(sys::fs::openFileForRead(TestPath.c_str(), TestFD));
 147   }
 148
 149   ErrorOr<OwningBuffer> Buf =
 150       MemoryBuffer::getOpenFileSlice(TestFD, TestPath.c_str(),
 151                                      40000, // Size
 152                                      80000  // Offset
 153                                      );
 154
 155   std::error_code EC = Buf.getError();
 156   EXPECT_FALSE(EC);
 157
 158   StringRef BufData = Buf.get()->getBuffer();
 159   EXPECT_EQ(BufData.size(), 40000U);
 160   EXPECT_EQ(BufData[0], '0');
 161   EXPECT_EQ(BufData[9], '9');
 162 }
 163
 164 TEST_F(MemoryBufferTest, getOpenFileNoReopen) {
 165   testGetOpenFileSlice(false);
 166 }
 167
 168 TEST_F(MemoryBufferTest, getOpenFileReopened) {
 169   testGetOpenFileSlice(true);
 170 }
 171
 172 TEST_F(MemoryBufferTest, reference) {
 173   OwningBuffer MB(MemoryBuffer::getMemBuffer(data));
 174   MemoryBufferRef MBR(*MB);
 175
 176   EXPECT_EQ(MB->getBufferStart(), MBR.getBufferStart());
 177   EXPECT_EQ(MB->getBufferIdentifier(), MBR.getBufferIdentifier());
 178 }
 179
 180 TEST_F(MemoryBufferTest, slice) {
 181   // Create a file that is six pages long with different data on each page.
 182   int FD;
 183   SmallString<64> TestPath;
 184   sys::fs::createTemporaryFile("MemoryBufferTest_Slice", "temp", FD, TestPath);
 185   raw_fd_ostream OF(FD, true, /*unbuffered=*/true);
 186   for (unsigned i = 0; i < 0x2000 / 8; ++i) {
 187     OF << "12345678";
 188   }
 189   for (unsigned i = 0; i < 0x2000 / 8; ++i) {
 190     OF << "abcdefgh";
 191   }
 192   for (unsigned i = 0; i < 0x2000 / 8; ++i) {
 193     OF << "ABCDEFGH";
 194   }
 195   OF.close();
 196
 197   // Try offset of one page.
 198   ErrorOr<OwningBuffer> MB = MemoryBuffer::getFileSlice(TestPath.str(),
 199                                                         0x4000, 0x1000);
 200   std::error_code EC = MB.getError();
 201   ASSERT_FALSE(EC);
 202   EXPECT_EQ(0x4000UL, MB.get()->getBufferSize());
 203
 204   StringRef BufData = MB.get()->getBuffer();
 205   EXPECT_TRUE(BufData.substr(0x0000,8).equals("12345678"));
 206   EXPECT_TRUE(BufData.substr(0x0FF8,8).equals("12345678"));
 207   EXPECT_TRUE(BufData.substr(0x1000,8).equals("abcdefgh"));
 208   EXPECT_TRUE(BufData.substr(0x2FF8,8).equals("abcdefgh"));
 209   EXPECT_TRUE(BufData.substr(0x3000,8).equals("ABCDEFGH"));
 210   EXPECT_TRUE(BufData.substr(0x3FF8,8).equals("ABCDEFGH"));
 211
 212   // Try non-page aligned.
 213   ErrorOr<OwningBuffer> MB2 = MemoryBuffer::getFileSlice(TestPath.str(),
 214                                                          0x3000, 0x0800);
 215   EC = MB2.getError();
 216   ASSERT_FALSE(EC);
 217   EXPECT_EQ(0x3000UL, MB2.get()->getBufferSize());
 218
 219   StringRef BufData2 = MB2.get()->getBuffer();
 220   EXPECT_TRUE(BufData2.substr(0x0000,8).equals("12345678"));
 221   EXPECT_TRUE(BufData2.substr(0x17F8,8).equals("12345678"));
 222   EXPECT_TRUE(BufData2.substr(0x1800,8).equals("abcdefgh"));
 223   EXPECT_TRUE(BufData2.substr(0x2FF8,8).equals("abcdefgh"));
 224 }
 225 }