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
 173 TEST_F(MemoryBufferTest, slice) {
 174   // Create a file that is six pages long with different data on each page.
 175   int FD;
 176   SmallString<64> TestPath;
 177   sys::fs::createTemporaryFile("MemoryBufferTest_Slice", "temp", FD, TestPath);
 178   raw_fd_ostream OF(FD, true, /*unbuffered=*/true);
 179   for (unsigned i = 0; i < 0x2000 / 8; ++i) {
 180     OF << "12345678";
 181   }
 182   for (unsigned i = 0; i < 0x2000 / 8; ++i) {
 183     OF << "abcdefgh";
 184   }
 185   for (unsigned i = 0; i < 0x2000 / 8; ++i) {
 186     OF << "ABCDEFGH";
 187   }
 188   OF.close();
 189
 190   // Try offset of one page.
 191   ErrorOr<OwningBuffer> MB = MemoryBuffer::getFileSlice(TestPath.str(),
 192                                                         0x4000, 0x1000);
 193   std::error_code EC = MB.getError();
 194   ASSERT_FALSE(EC);
 195   EXPECT_EQ(0x4000UL, MB.get()->getBufferSize());
 196
 197   StringRef BufData = MB.get()->getBuffer();
 198   EXPECT_TRUE(BufData.substr(0x0000,8).equals("12345678"));
 199   EXPECT_TRUE(BufData.substr(0x0FF8,8).equals("12345678"));
 200   EXPECT_TRUE(BufData.substr(0x1000,8).equals("abcdefgh"));
 201   EXPECT_TRUE(BufData.substr(0x2FF8,8).equals("abcdefgh"));
 202   EXPECT_TRUE(BufData.substr(0x3000,8).equals("ABCDEFGH"));
 203   EXPECT_TRUE(BufData.substr(0x3FF8,8).equals("ABCDEFGH"));
 204
 205   // Try non-page aligned.
 206   ErrorOr<OwningBuffer> MB2 = MemoryBuffer::getFileSlice(TestPath.str(),
 207                                                          0x3000, 0x0800);
 208   EC = MB2.getError();
 209   ASSERT_FALSE(EC);
 210   EXPECT_EQ(0x3000UL, MB2.get()->getBufferSize());
 211
 212   StringRef BufData2 = MB2.get()->getBuffer();
 213   EXPECT_TRUE(BufData2.substr(0x0000,8).equals("12345678"));
 214   EXPECT_TRUE(BufData2.substr(0x17F8,8).equals("12345678"));
 215   EXPECT_TRUE(BufData2.substr(0x1800,8).equals("abcdefgh"));
 216   EXPECT_TRUE(BufData2.substr(0x2FF8,8).equals("abcdefgh"));
 217
 218 }
 219
 220
 221
 222 }