Mercurial > hg > CbC > CbC_llvm

comparison unittests/Support/MemoryBufferTest.cpp @ 0:95c75e76d11b LLVM3.4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM 3.4
author Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date Thu, 12 Dec 2013 13:56:28 +0900
parents
children 54457678186b
comparison
equal deleted inserted replaced
-1:000000000000 0:95c75e76d11b
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 }