Support read/write memory-mapped files.

base/files/memory_mapped_file_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/files/memory_mapped_file.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 47 matching lines @@
  private:
   FilePath temp_file_path_;
 };
 
 TEST_F(MemoryMappedFileTest, MapWholeFileByPath) {
   const size_t kFileSize = 68 * 1024;
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
   map.Initialize(temp_file_path());
   ASSERT_EQ(kFileSize, map.length());
-  ASSERT_TRUE(map.data() != NULL);
+  ASSERT_TRUE(map.data() != nullptr);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
 }
 
 TEST_F(MemoryMappedFileTest, MapWholeFileByFD) {
   const size_t kFileSize = 68 * 1024;
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
   map.Initialize(File(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ));
   ASSERT_EQ(kFileSize, map.length());
-  ASSERT_TRUE(map.data() != NULL);
+  ASSERT_TRUE(map.data() != nullptr);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
 }
 
 TEST_F(MemoryMappedFileTest, MapSmallFile) {
   const size_t kFileSize = 127;
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
   map.Initialize(temp_file_path());
   ASSERT_EQ(kFileSize, map.length());
-  ASSERT_TRUE(map.data() != NULL);
+  ASSERT_TRUE(map.data() != nullptr);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
 }
 
 TEST_F(MemoryMappedFileTest, MapWholeFileUsingRegion) {
   const size_t kFileSize = 157 * 1024;
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
 
   File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
   map.Initialize(std::move(file), MemoryMappedFile::Region::kWholeFile);
   ASSERT_EQ(kFileSize, map.length());
-  ASSERT_TRUE(map.data() != NULL);
+  ASSERT_TRUE(map.data() != nullptr);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
 }
 
 TEST_F(MemoryMappedFileTest, MapPartialRegionAtBeginning) {
   const size_t kFileSize = 157 * 1024;
   const size_t kPartialSize = 4 * 1024 + 32;
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
 
   File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
   MemoryMappedFile::Region region = {0, kPartialSize};
   map.Initialize(std::move(file), region);
   ASSERT_EQ(kPartialSize, map.length());
-  ASSERT_TRUE(map.data() != NULL);
+  ASSERT_TRUE(map.data() != nullptr);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, 0));
 }
 
 TEST_F(MemoryMappedFileTest, MapPartialRegionAtEnd) {
   const size_t kFileSize = 157 * 1024;
   const size_t kPartialSize = 5 * 1024 - 32;
   const size_t kOffset = kFileSize - kPartialSize;
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
 
   File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
   MemoryMappedFile::Region region = {kOffset, kPartialSize};
   map.Initialize(std::move(file), region);
   ASSERT_EQ(kPartialSize, map.length());
-  ASSERT_TRUE(map.data() != NULL);
+  ASSERT_TRUE(map.data() != nullptr);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, kOffset));
 }
 
 TEST_F(MemoryMappedFileTest, MapSmallPartialRegionInTheMiddle) {
   const size_t kFileSize = 157 * 1024;
   const size_t kOffset = 1024 * 5 + 32;
   const size_t kPartialSize = 8;
 
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
 
   File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
   MemoryMappedFile::Region region = {kOffset, kPartialSize};
   map.Initialize(std::move(file), region);
   ASSERT_EQ(kPartialSize, map.length());
-  ASSERT_TRUE(map.data() != NULL);
+  ASSERT_TRUE(map.data() != nullptr);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, kOffset));
 }
 
 TEST_F(MemoryMappedFileTest, MapLargePartialRegionInTheMiddle) {
   const size_t kFileSize = 157 * 1024;
   const size_t kOffset = 1024 * 5 + 32;
   const size_t kPartialSize = 16 * 1024 - 32;
 
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
 
   File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
   MemoryMappedFile::Region region = {kOffset, kPartialSize};
   map.Initialize(std::move(file), region);
   ASSERT_EQ(kPartialSize, map.length());
-  ASSERT_TRUE(map.data() != NULL);
+  ASSERT_TRUE(map.data() != nullptr);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, kOffset));
 }
 
+TEST_F(MemoryMappedFileTest, WriteableFile) {
+  const size_t kFileSize = 127;
+  CreateTemporaryTestFile(kFileSize);
+
+  {
+    MemoryMappedFile map;
+    map.Initialize(temp_file_path(), MemoryMappedFile::READ_WRITE);
+    ASSERT_EQ(kFileSize, map.length());
+    ASSERT_TRUE(map.data() != nullptr);
+    EXPECT_TRUE(map.IsValid());
+    ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
+
+    uint8_t* bytes = map.data();
+    bytes[0] = 'B';
+    bytes[1] = 'a';
+    bytes[2] = 'r';
+    bytes[kFileSize - 1] = '!';
+    EXPECT_FALSE(CheckBufferContents(map.data(), kFileSize, 0));
+    EXPECT_TRUE(CheckBufferContents(map.data() + 3, kFileSize - 4, 3));
+  }
+
+  int64_t file_size;
+  ASSERT_TRUE(GetFileSize(temp_file_path(), &file_size));
+  EXPECT_EQ(static_cast<int64_t>(kFileSize), file_size);
+
+  std::string contents;
+  ASSERT_TRUE(ReadFileToString(temp_file_path(), &contents));
+  EXPECT_EQ("Bar", contents.substr(0, 3));
+  EXPECT_EQ("!", contents.substr(kFileSize - 1, 1));
+}
+
+TEST_F(MemoryMappedFileTest, ExtendableFile) {
+  const size_t kFileSize = 127;
+  const size_t kFileExtend = 100;
+  CreateTemporaryTestFile(kFileSize);
+
+  {
+    File file(temp_file_path(),
+              File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE);
+    MemoryMappedFile::Region region = {0, kFileSize + kFileExtend};
+    MemoryMappedFile map;
+    map.Initialize(std::move(file), region,
+                   MemoryMappedFile::READ_WRITE_EXTEND);
+    EXPECT_EQ(kFileSize + kFileExtend, map.length());
+    ASSERT_TRUE(map.data() != nullptr);
+    EXPECT_TRUE(map.IsValid());
+    ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
+
+    uint8_t* bytes = map.data();
+    EXPECT_EQ(0, bytes[kFileSize + 0]);
+    EXPECT_EQ(0, bytes[kFileSize + 1]);
+    EXPECT_EQ(0, bytes[kFileSize + 2]);
+    bytes[kFileSize + 0] = 'B';
+    bytes[kFileSize + 1] = 'A';
+    bytes[kFileSize + 2] = 'Z';
+    EXPECT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
+  }
+
+  int64_t file_size;
+  ASSERT_TRUE(GetFileSize(temp_file_path(), &file_size));
+  EXPECT_LE(static_cast<int64_t>(kFileSize + 3), file_size);
+  EXPECT_GE(static_cast<int64_t>(kFileSize + kFileExtend), file_size);
+
+  std::string contents;
+  ASSERT_TRUE(ReadFileToString(temp_file_path(), &contents));
+  EXPECT_EQ("BAZ", contents.substr(kFileSize, 3));
+}
+
 }  // namespace
 
 }  // namespace base