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>

#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"

namespace base {

namespace {

// Create a temporary buffer and fill it with a watermark sequence.
std::unique_ptr<uint8_t[]> CreateTestBuffer(size_t size, size_t offset) {
  std::unique_ptr<uint8_t[]> buf(new uint8_t[size]);
  for (size_t i = 0; i < size; ++i)
    buf.get()[i] = static_cast<uint8_t>((offset + i) % 253);
  return buf;
}

// Check that the watermark sequence is consistent with the |offset| provided.
bool CheckBufferContents(const uint8_t* data, size_t size, size_t offset) {
  std::unique_ptr<uint8_t[]> test_data(CreateTestBuffer(size, offset));
  return memcmp(test_data.get(), data, size) == 0;
}

class MemoryMappedFileTest : public PlatformTest {
 protected:
  void SetUp() override {
    PlatformTest::SetUp();
    CreateTemporaryFile(&temp_file_path_);
  }

  void TearDown() override { EXPECT_TRUE(DeleteFile(temp_file_path_, false)); }

  void CreateTemporaryTestFile(size_t size) {
    File file(temp_file_path_,
              File::FLAG_CREATE_ALWAYS | File::FLAG_READ | File::FLAG_WRITE);
    EXPECT_TRUE(file.IsValid());

    std::unique_ptr<uint8_t[]> test_data(CreateTestBuffer(size, 0));
    size_t bytes_written =
        file.Write(0, reinterpret_cast<char*>(test_data.get()), size);
    EXPECT_EQ(size, bytes_written);
    file.Close();
  }

  const FilePath temp_file_path() const { return temp_file_path_; }

 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() != 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() != 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() != 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() != 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() != 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() != 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() != 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() != 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