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 } 172