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 "llvm/ADT/OwningPtr.h"
  18 #include "gtest/gtest.h"
  19
  20 using namespace llvm;
  21
  22 namespace {
  23
  24 class MemoryBufferTest : public testing::Test {
  25 protected:
  26   MemoryBufferTest()
  27   : data("this is some data")
  28   { }
  29
  30   virtual void SetUp() { }
  31
  32   /// Common testing for different modes of getOpenFileSlice.
  33   /// Creates a temporary file with known contents, and uses
  34   /// MemoryBuffer::getOpenFileSlice to map it.
  35   /// If \p Reopen is true, the file is closed after creating and reopened
  36   /// anew before using MemoryBuffer.
  37   void testGetOpenFileSlice(bool Reopen);
  38
  39   typedef OwningPtr<MemoryBuffer> OwningBuffer;
  40
  41   std::string data;
  42 };
  43
  44 TEST_F(MemoryBufferTest, get) {
  45   // Default name and null-terminator flag
  46   OwningBuffer MB1(MemoryBuffer::getMemBuffer(data));
  47   EXPECT_TRUE(0 != MB1.get());
  48
  49   // RequiresNullTerminator = false
  50   OwningBuffer MB2(MemoryBuffer::getMemBuffer(data, "one", false));
  51   EXPECT_TRUE(0 != MB2.get());
  52
  53   // RequiresNullTerminator = true
  54   OwningBuffer MB3(MemoryBuffer::getMemBuffer(data, "two", true));
  55   EXPECT_TRUE(0 != MB3.get());
  56
  57   // verify all 3 buffers point to the same address
  58   EXPECT_EQ(MB1->getBufferStart(), MB2->getBufferStart());
  59   EXPECT_EQ(MB2->getBufferStart(), MB3->getBufferStart());
  60
  61   // verify the original data is unmodified after deleting the buffers
  62   MB1.reset();
  63   MB2.reset();
  64   MB3.reset();
  65   EXPECT_EQ("this is some data", data);
  66 }
  67
  68 TEST_F(MemoryBufferTest, NullTerminator4K) {
  69   // Test that a file with size that is a multiple of the page size can be null
  70   // terminated correctly by MemoryBuffer.
  71   int TestFD;
  72   SmallString<64> TestPath;
  73   sys::fs::createTemporaryFile("MemoryBufferTest_NullTerminator4K", "temp",
  74                                TestFD, TestPath);
  75   raw_fd_ostream OF(TestFD, true, /*unbuffered=*/true);
  76   for (unsigned i = 0; i < 4096 / 16; ++i) {
  77     OF << "0123456789abcdef";
  78   }
  79   OF.close();
  80
  81   OwningPtr<MemoryBuffer> MB;
  82   error_code EC = MemoryBuffer::getFile(TestPath.c_str(), MB);
  83   ASSERT_FALSE(EC);
  84
  85   const char *BufData = MB->getBufferStart();
  86   EXPECT_EQ('f', BufData[4095]);
  87   EXPECT_EQ('\0', BufData[4096]);
  88 }
  89
  90 TEST_F(MemoryBufferTest, copy) {
  91   // copy with no name
  92   OwningBuffer MBC1(MemoryBuffer::getMemBufferCopy(data));
  93   EXPECT_TRUE(0 != MBC1.get());
  94
  95   // copy with a name
  96   OwningBuffer MBC2(MemoryBuffer::getMemBufferCopy(data, "copy"));
  97   EXPECT_TRUE(0 != MBC2.get());
  98
  99   // verify the two copies do not point to the same place
 100   EXPECT_NE(MBC1->getBufferStart(), MBC2->getBufferStart());
 101 }
 102
 103 TEST_F(MemoryBufferTest, make_new) {
 104   // 0-sized buffer
 105   OwningBuffer Zero(MemoryBuffer::getNewUninitMemBuffer(0));
 106   EXPECT_TRUE(0 != Zero.get());
 107
 108   // uninitialized buffer with no name
 109   OwningBuffer One(MemoryBuffer::getNewUninitMemBuffer(321));
 110   EXPECT_TRUE(0 != One.get());
 111
 112   // uninitialized buffer with name
 113   OwningBuffer Two(MemoryBuffer::getNewUninitMemBuffer(123, "bla"));
 114   EXPECT_TRUE(0 != Two.get());
 115
 116   // 0-initialized buffer with no name
 117   OwningBuffer Three(MemoryBuffer::getNewMemBuffer(321, data));
 118   EXPECT_TRUE(0 != Three.get());
 119   for (size_t i = 0; i < 321; ++i)
 120     EXPECT_EQ(0, Three->getBufferStart()[0]);
 121
 122   // 0-initialized buffer with name
 123   OwningBuffer Four(MemoryBuffer::getNewMemBuffer(123, "zeros"));
 124   EXPECT_TRUE(0 != Four.get());
 125   for (size_t i = 0; i < 123; ++i)
 126     EXPECT_EQ(0, Four->getBufferStart()[0]);
 127 }
 128
 129 void MemoryBufferTest::testGetOpenFileSlice(bool Reopen) {
 130   // Test that MemoryBuffer::getOpenFile works properly when no null
 131   // terminator is requested and the size is large enough to trigger
 132   // the usage of memory mapping.
 133   int TestFD;
 134   SmallString<64> TestPath;
 135   // Create a temporary file and write data into it.
 136   sys::fs::createTemporaryFile("prefix", "temp", TestFD, TestPath);
 137   // OF is responsible for closing the file; If the file is not
 138   // reopened, it will be unbuffered so that the results are
 139   // immediately visible through the fd.
 140   raw_fd_ostream OF(TestFD, true, !Reopen);
 141   for (int i = 0; i < 60000; ++i) {
 142     OF << "0123456789";
 143   }
 144
 145   if (Reopen) {
 146     OF.close();
 147     EXPECT_FALSE(sys::fs::openFileForRead(TestPath.c_str(), TestFD));
 148   }
 149
 150   OwningBuffer Buf;
 151   error_code EC = MemoryBuffer::getOpenFileSlice(TestFD, TestPath.c_str(), Buf,
 152                                                  40000, // Size
 153                                                  80000  // Offset
 154                                                  );
 155   EXPECT_FALSE(EC);
 156
 157   StringRef BufData = Buf->getBuffer();
 158   EXPECT_EQ(BufData.size(), 40000U);
 159   EXPECT_EQ(BufData[0], '0');
 160   EXPECT_EQ(BufData[9], '9');
 161 }
 162
 163 TEST_F(MemoryBufferTest, getOpenFileNoReopen) {
 164   testGetOpenFileSlice(false);
 165 }
 166
 167 TEST_F(MemoryBufferTest, getOpenFileReopened) {
 168   testGetOpenFileSlice(true);
 169 }
 170
 171 }