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 class MemoryBufferTest : public testing::Test {
  23 protected:
  24   MemoryBufferTest()
  25   : data("this is some data")
  26   { }
  27
  28   virtual void SetUp() { }
  29
  30   typedef OwningPtr<MemoryBuffer> OwningBuffer;
  31
  32   std::string data;
  33 };
  34
  35 namespace {
  36
  37 TEST_F(MemoryBufferTest, get) {
  38   // Default name and null-terminator flag
  39   OwningBuffer MB1(MemoryBuffer::getMemBuffer(data));
  40   EXPECT_TRUE(0 != MB1.get());
  41
  42   // RequiresNullTerminator = false
  43   OwningBuffer MB2(MemoryBuffer::getMemBuffer(data, "one", false));
  44   EXPECT_TRUE(0 != MB2.get());
  45
  46   // RequiresNullTerminator = true
  47   OwningBuffer MB3(MemoryBuffer::getMemBuffer(data, "two", true));
  48   EXPECT_TRUE(0 != MB3.get());
  49
  50   // verify all 3 buffers point to the same address
  51   EXPECT_EQ(MB1->getBufferStart(), MB2->getBufferStart());
  52   EXPECT_EQ(MB2->getBufferStart(), MB3->getBufferStart());
  53
  54   // verify the original data is unmodified after deleting the buffers
  55   MB1.reset();
  56   MB2.reset();
  57   MB3.reset();
  58   EXPECT_EQ("this is some data", data);
  59 }
  60
  61 TEST_F(MemoryBufferTest, copy) {
  62   // copy with no name
  63   OwningBuffer MBC1(MemoryBuffer::getMemBufferCopy(data));
  64   EXPECT_TRUE(0 != MBC1.get());
  65
  66   // copy with a name
  67   OwningBuffer MBC2(MemoryBuffer::getMemBufferCopy(data, "copy"));
  68   EXPECT_TRUE(0 != MBC2.get());
  69
  70   // verify the two copies do not point to the same place
  71   EXPECT_NE(MBC1->getBufferStart(), MBC2->getBufferStart());
  72 }
  73
  74 TEST_F(MemoryBufferTest, make_new) {
  75   // 0-sized buffer
  76   OwningBuffer Zero(MemoryBuffer::getNewUninitMemBuffer(0));
  77   EXPECT_TRUE(0 != Zero.get());
  78
  79   // uninitialized buffer with no name
  80   OwningBuffer One(MemoryBuffer::getNewUninitMemBuffer(321));
  81   EXPECT_TRUE(0 != One.get());
  82
  83   // uninitialized buffer with name
  84   OwningBuffer Two(MemoryBuffer::getNewUninitMemBuffer(123, "bla"));
  85   EXPECT_TRUE(0 != Two.get());
  86
  87   // 0-initialized buffer with no name
  88   OwningBuffer Three(MemoryBuffer::getNewMemBuffer(321, data));
  89   EXPECT_TRUE(0 != Three.get());
  90   for (size_t i = 0; i < 321; ++i)
  91     EXPECT_EQ(0, Three->getBufferStart()[0]);
  92
  93   // 0-initialized buffer with name
  94   OwningBuffer Four(MemoryBuffer::getNewMemBuffer(123, "zeros"));
  95   EXPECT_TRUE(0 != Four.get());
  96   for (size_t i = 0; i < 123; ++i)
  97     EXPECT_EQ(0, Four->getBufferStart()[0]);
  98 }
  99
 100 TEST_F(MemoryBufferTest, getOpenFileNoNullTerminator) {
 101   // Test that MemoryBuffer::getOpenFile works properly when no null
 102   // terminator is requested and the size is large enough to trigger
 103   // the usage of memory mapping.
 104   int TestFD;
 105   SmallString<64> TestPath;
 106   // Create a temporary file and write data into it.
 107   sys::fs::createTemporaryFile("prefix", "temp", TestFD, TestPath);
 108   // OF is responsible for closing the file, and is unbuffered so that
 109   // the results are immediately visible through the fd.
 110   raw_fd_ostream OF(TestFD, true, true);
 111   for (int i = 0; i < 60000; ++i) {
 112     OF << "0123456789";
 113   }
 114
 115   OwningBuffer Buf;
 116   error_code EC = MemoryBuffer::getOpenFile(TestFD,
 117                                             TestPath.c_str(),
 118                                             Buf,
 119                                             40000,    // Size
 120                                             -1,
 121                                             8000,     // Offset
 122                                             false);
 123   EXPECT_FALSE(EC);
 124
 125   StringRef BufData = Buf->getBuffer();
 126   EXPECT_EQ(BufData.size(), 40000U);
 127   EXPECT_EQ(BufData[0], '0');
 128   EXPECT_EQ(BufData[9], '9');
 129 }
 130
 131 }