MemoryBufferTest.cpp revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338 
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/ADT/OwningPtr.h"
16#include "llvm/Support/MemoryBuffer.h"
17#include "llvm/Support/raw_ostream.h"
18#include "gtest/gtest.h"
19
20using namespace llvm;
21
22namespace {
23
24class MemoryBufferTest : public testing::Test {
25protected:
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
44TEST_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
68TEST_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  OwningBuffer 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
90TEST_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
103TEST_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
129void 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
163TEST_F(MemoryBufferTest, getOpenFileNoReopen) {
164  testGetOpenFileSlice(false);
165}
166
167TEST_F(MemoryBufferTest, getOpenFileReopened) {
168  testGetOpenFileSlice(true);
169}
170
171}
172