1 //===- llvm/unittest/Support/MemoryBufferTest.cpp - MemoryBuffer tests ----===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements unit tests for the MemoryBuffer support class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/Support/MemoryBuffer.h" 14 #include "llvm/Support/FileSystem.h" 15 #include "llvm/Support/FileUtilities.h" 16 #include "llvm/Support/raw_ostream.h" 17 #include "llvm/Testing/Support/Error.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 void SetUp() override {} 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 std::unique_ptr<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(nullptr != MB1.get()); 48 49 // RequiresNullTerminator = false 50 OwningBuffer MB2(MemoryBuffer::getMemBuffer(data, "one", false)); 51 EXPECT_TRUE(nullptr != MB2.get()); 52 53 // RequiresNullTerminator = true 54 OwningBuffer MB3(MemoryBuffer::getMemBuffer(data, "two", true)); 55 EXPECT_TRUE(nullptr != 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 FileRemover Cleanup(TestPath); 76 raw_fd_ostream OF(TestFD, true, /*unbuffered=*/true); 77 for (unsigned i = 0; i < 4096 / 16; ++i) { 78 OF << "0123456789abcdef"; 79 } 80 OF.close(); 81 82 ErrorOr<OwningBuffer> MB = MemoryBuffer::getFile(TestPath.c_str()); 83 std::error_code EC = MB.getError(); 84 ASSERT_FALSE(EC); 85 86 const char *BufData = MB.get()->getBufferStart(); 87 EXPECT_EQ('f', BufData[4095]); 88 EXPECT_EQ('\0', BufData[4096]); 89 } 90 91 TEST_F(MemoryBufferTest, copy) { 92 // copy with no name 93 OwningBuffer MBC1(MemoryBuffer::getMemBufferCopy(data)); 94 EXPECT_TRUE(nullptr != MBC1.get()); 95 96 // copy with a name 97 OwningBuffer MBC2(MemoryBuffer::getMemBufferCopy(data, "copy")); 98 EXPECT_TRUE(nullptr != MBC2.get()); 99 100 // verify the two copies do not point to the same place 101 EXPECT_NE(MBC1->getBufferStart(), MBC2->getBufferStart()); 102 } 103 104 TEST_F(MemoryBufferTest, make_new) { 105 // 0-sized buffer 106 OwningBuffer Zero(WritableMemoryBuffer::getNewUninitMemBuffer(0)); 107 EXPECT_TRUE(nullptr != Zero.get()); 108 109 // uninitialized buffer with no name 110 OwningBuffer One(WritableMemoryBuffer::getNewUninitMemBuffer(321)); 111 EXPECT_TRUE(nullptr != One.get()); 112 113 // uninitialized buffer with name 114 OwningBuffer Two(WritableMemoryBuffer::getNewUninitMemBuffer(123, "bla")); 115 EXPECT_TRUE(nullptr != Two.get()); 116 117 // 0-initialized buffer with no name 118 OwningBuffer Three(WritableMemoryBuffer::getNewMemBuffer(321, data)); 119 EXPECT_TRUE(nullptr != Three.get()); 120 for (size_t i = 0; i < 321; ++i) 121 EXPECT_EQ(0, Three->getBufferStart()[0]); 122 123 // 0-initialized buffer with name 124 OwningBuffer Four(WritableMemoryBuffer::getNewMemBuffer(123, "zeros")); 125 EXPECT_TRUE(nullptr != Four.get()); 126 for (size_t i = 0; i < 123; ++i) 127 EXPECT_EQ(0, Four->getBufferStart()[0]); 128 } 129 130 void MemoryBufferTest::testGetOpenFileSlice(bool Reopen) { 131 // Test that MemoryBuffer::getOpenFile works properly when no null 132 // terminator is requested and the size is large enough to trigger 133 // the usage of memory mapping. 134 int TestFD; 135 SmallString<64> TestPath; 136 // Create a temporary file and write data into it. 137 sys::fs::createTemporaryFile("prefix", "temp", TestFD, TestPath); 138 FileRemover Cleanup(TestPath); 139 // OF is responsible for closing the file; If the file is not 140 // reopened, it will be unbuffered so that the results are 141 // immediately visible through the fd. 142 raw_fd_ostream OF(TestFD, true, !Reopen); 143 for (int i = 0; i < 60000; ++i) { 144 OF << "0123456789"; 145 } 146 147 if (Reopen) { 148 OF.close(); 149 EXPECT_FALSE(sys::fs::openFileForRead(TestPath.c_str(), TestFD)); 150 } 151 152 ErrorOr<OwningBuffer> Buf = 153 MemoryBuffer::getOpenFileSlice(TestFD, TestPath.c_str(), 154 40000, // Size 155 80000 // Offset 156 ); 157 158 std::error_code EC = Buf.getError(); 159 EXPECT_FALSE(EC); 160 161 StringRef BufData = Buf.get()->getBuffer(); 162 EXPECT_EQ(BufData.size(), 40000U); 163 EXPECT_EQ(BufData[0], '0'); 164 EXPECT_EQ(BufData[9], '9'); 165 } 166 167 TEST_F(MemoryBufferTest, getOpenFileNoReopen) { 168 testGetOpenFileSlice(false); 169 } 170 171 TEST_F(MemoryBufferTest, getOpenFileReopened) { 172 testGetOpenFileSlice(true); 173 } 174 175 TEST_F(MemoryBufferTest, reference) { 176 OwningBuffer MB(MemoryBuffer::getMemBuffer(data)); 177 MemoryBufferRef MBR(*MB); 178 179 EXPECT_EQ(MB->getBufferStart(), MBR.getBufferStart()); 180 EXPECT_EQ(MB->getBufferIdentifier(), MBR.getBufferIdentifier()); 181 } 182 183 TEST_F(MemoryBufferTest, slice) { 184 // Create a file that is six pages long with different data on each page. 185 int FD; 186 SmallString<64> TestPath; 187 sys::fs::createTemporaryFile("MemoryBufferTest_Slice", "temp", FD, TestPath); 188 FileRemover Cleanup(TestPath); 189 raw_fd_ostream OF(FD, true, /*unbuffered=*/true); 190 for (unsigned i = 0; i < 0x2000 / 8; ++i) { 191 OF << "12345678"; 192 } 193 for (unsigned i = 0; i < 0x2000 / 8; ++i) { 194 OF << "abcdefgh"; 195 } 196 for (unsigned i = 0; i < 0x2000 / 8; ++i) { 197 OF << "ABCDEFGH"; 198 } 199 OF.close(); 200 201 // Try offset of one page. 202 ErrorOr<OwningBuffer> MB = MemoryBuffer::getFileSlice(TestPath.str(), 203 0x4000, 0x1000); 204 std::error_code EC = MB.getError(); 205 ASSERT_FALSE(EC); 206 EXPECT_EQ(0x4000UL, MB.get()->getBufferSize()); 207 208 StringRef BufData = MB.get()->getBuffer(); 209 EXPECT_TRUE(BufData.substr(0x0000,8).equals("12345678")); 210 EXPECT_TRUE(BufData.substr(0x0FF8,8).equals("12345678")); 211 EXPECT_TRUE(BufData.substr(0x1000,8).equals("abcdefgh")); 212 EXPECT_TRUE(BufData.substr(0x2FF8,8).equals("abcdefgh")); 213 EXPECT_TRUE(BufData.substr(0x3000,8).equals("ABCDEFGH")); 214 EXPECT_TRUE(BufData.substr(0x3FF8,8).equals("ABCDEFGH")); 215 216 // Try non-page aligned. 217 ErrorOr<OwningBuffer> MB2 = MemoryBuffer::getFileSlice(TestPath.str(), 218 0x3000, 0x0800); 219 EC = MB2.getError(); 220 ASSERT_FALSE(EC); 221 EXPECT_EQ(0x3000UL, MB2.get()->getBufferSize()); 222 223 StringRef BufData2 = MB2.get()->getBuffer(); 224 EXPECT_TRUE(BufData2.substr(0x0000,8).equals("12345678")); 225 EXPECT_TRUE(BufData2.substr(0x17F8,8).equals("12345678")); 226 EXPECT_TRUE(BufData2.substr(0x1800,8).equals("abcdefgh")); 227 EXPECT_TRUE(BufData2.substr(0x2FF8,8).equals("abcdefgh")); 228 } 229 230 TEST_F(MemoryBufferTest, writableSlice) { 231 // Create a file initialized with some data 232 int FD; 233 SmallString<64> TestPath; 234 sys::fs::createTemporaryFile("MemoryBufferTest_WritableSlice", "temp", FD, 235 TestPath); 236 FileRemover Cleanup(TestPath); 237 raw_fd_ostream OF(FD, true); 238 for (unsigned i = 0; i < 0x1000; ++i) 239 OF << "0123456789abcdef"; 240 OF.close(); 241 242 { 243 auto MBOrError = 244 WritableMemoryBuffer::getFileSlice(TestPath.str(), 0x6000, 0x2000); 245 ASSERT_FALSE(MBOrError.getError()); 246 // Write some data. It should be mapped private, so that upon completion 247 // the original file contents are not modified. 248 WritableMemoryBuffer &MB = **MBOrError; 249 ASSERT_EQ(0x6000u, MB.getBufferSize()); 250 char *Start = MB.getBufferStart(); 251 ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize()); 252 ::memset(Start, 'x', MB.getBufferSize()); 253 } 254 255 auto MBOrError = MemoryBuffer::getFile(TestPath); 256 ASSERT_FALSE(MBOrError.getError()); 257 auto &MB = **MBOrError; 258 ASSERT_EQ(0x10000u, MB.getBufferSize()); 259 for (size_t i = 0; i < MB.getBufferSize(); i += 0x10) 260 EXPECT_EQ("0123456789abcdef", MB.getBuffer().substr(i, 0x10)) << "i: " << i; 261 } 262 263 TEST_F(MemoryBufferTest, writeThroughFile) { 264 // Create a file initialized with some data 265 int FD; 266 SmallString<64> TestPath; 267 sys::fs::createTemporaryFile("MemoryBufferTest_WriteThrough", "temp", FD, 268 TestPath); 269 FileRemover Cleanup(TestPath); 270 raw_fd_ostream OF(FD, true); 271 OF << "0123456789abcdef"; 272 OF.close(); 273 { 274 auto MBOrError = WriteThroughMemoryBuffer::getFile(TestPath); 275 ASSERT_FALSE(MBOrError.getError()); 276 // Write some data. It should be mapped readwrite, so that upon completion 277 // the original file contents are modified. 278 WriteThroughMemoryBuffer &MB = **MBOrError; 279 ASSERT_EQ(16u, MB.getBufferSize()); 280 char *Start = MB.getBufferStart(); 281 ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize()); 282 ::memset(Start, 'x', MB.getBufferSize()); 283 } 284 285 auto MBOrError = MemoryBuffer::getFile(TestPath); 286 ASSERT_FALSE(MBOrError.getError()); 287 auto &MB = **MBOrError; 288 ASSERT_EQ(16u, MB.getBufferSize()); 289 EXPECT_EQ("xxxxxxxxxxxxxxxx", MB.getBuffer()); 290 } 291 } 292