src/storage/lib/vfs/cpp/tests/vmo_file_tests.cc

// Copyright 2017 The Fuchsia 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 <fidl/fuchsia.io/cpp/common_types.h>
#include <fidl/fuchsia.io/cpp/natural_types.h>
#include <fidl/fuchsia.io/cpp/wire.h>
#include <lib/zx/result.h>
#include <lib/zx/vmo.h>
#include <zircon/errors.h>
#include <zircon/rights.h>
#include <zircon/syscalls.h>
#include <zircon/syscalls/object.h>
#include <zircon/types.h>

#include <cstddef>
#include <cstdint>
#include <cstring>
#include <memory>
#include <utility>

#include <fbl/ref_ptr.h>
#include <gtest/gtest.h>

#include "src/storage/lib/vfs/cpp/vfs_types.h"
#include "src/storage/lib/vfs/cpp/vmo_file.h"

namespace {

const size_t VMO_SIZE = zx_system_get_page_size() * 3u;
const size_t PAGE_0 = 0u;
const size_t PAGE_1 = zx_system_get_page_size();
const size_t PAGE_2 = zx_system_get_page_size() * 2u;

zx_koid_t GetKoid(zx_handle_t handle) {
  zx_info_handle_basic_t info;
  zx_status_t status =
      zx_object_get_info(handle, ZX_INFO_HANDLE_BASIC, &info, sizeof(info), nullptr, nullptr);
  return status == ZX_OK ? info.koid : ZX_KOID_INVALID;
}

zx_rights_t GetRights(zx_handle_t handle) {
  zx_info_handle_basic_t info;
  zx_status_t status =
      zx_object_get_info(handle, ZX_INFO_HANDLE_BASIC, &info, sizeof(info), nullptr, nullptr);
  return status == ZX_OK ? info.rights : 0u;
}

void FillVmo(const zx::vmo& vmo, size_t offset, size_t length, uint8_t byte) {
  auto data = std::make_unique<uint8_t[]>(length);
  memset(data.get(), byte, length);

  zx_status_t status = vmo.write(data.get(), offset, length);
  ASSERT_EQ(ZX_OK, status);
}

void CheckVmo(const zx::vmo& vmo, size_t offset, size_t length, uint8_t expected_byte) {
  auto data = std::make_unique<uint8_t[]>(length);

  zx_status_t status = vmo.read(data.get(), offset, length);
  ASSERT_EQ(ZX_OK, status);

  for (size_t i = 0; i < length; i++) {
    ASSERT_EQ(expected_byte, data[i]);
  }
}

void CheckData(uint8_t* data, size_t offset, size_t length, uint8_t expected_byte) {
  for (size_t i = 0; i < length; i++) {
    ASSERT_EQ(expected_byte, data[i + offset]);
  }
}

void CreateVmoABC(zx::vmo* out_vmo) {
  zx_status_t status = zx::vmo::create(VMO_SIZE, 0u, out_vmo);
  ASSERT_EQ(ZX_OK, status);

  FillVmo(*out_vmo, PAGE_0, zx_system_get_page_size(), 'A');
  FillVmo(*out_vmo, PAGE_1, zx_system_get_page_size(), 'B');
  FillVmo(*out_vmo, PAGE_2, zx_system_get_page_size(), 'C');
}

TEST(VmoFile, Constructor) {
  zx::vmo abc;
  CreateVmoABC(&abc);

  // default parameters
  {
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));

    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), zx_system_get_page_size());
    EXPECT_EQ(zx_system_get_page_size(), file->length());
    EXPECT_FALSE(file->is_writable());
  }

  // everything explicit
  {
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));

    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), PAGE_2 + 1u, true,
                                                 fs::VmoFile::DefaultSharingMode::kCloneCow);
    EXPECT_EQ(PAGE_2 + 1u, file->length());
    EXPECT_TRUE(file->is_writable());
  }
}

TEST(VmoFile, Open) {
  zx::vmo abc;
  CreateVmoABC(&abc);
  auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(abc), 0u, /*writable=*/false);
  fbl::RefPtr<fs::Vnode> redirect;
  ASSERT_EQ(ZX_OK, file->Open(&redirect));
  ASSERT_EQ(redirect, nullptr);
}

TEST(VmoFile, Protocols) {
  zx::vmo abc;
  CreateVmoABC(&abc);
  auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(abc), 0u, /*writable=*/false);
  ASSERT_EQ(file->GetProtocols(), fuchsia_io::NodeProtocolKinds::kFile);
}

TEST(VmoFile, ValidateRights) {
  zx::vmo abc;
  CreateVmoABC(&abc);

  // read-only
  {
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));

    auto read_only = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 0u, /*writable=*/false);
    ASSERT_TRUE(read_only->ValidateRights(fuchsia_io::Rights::kReadBytes));
    ASSERT_FALSE(read_only->ValidateRights(fuchsia_io::Rights::kWriteBytes));
    ASSERT_FALSE(read_only->ValidateRights(fuchsia_io::Rights::kExecute));
  }

  // writable
  {
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));

    auto writable = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 0u, /*writable=*/true);
    ASSERT_TRUE(writable->ValidateRights(fuchsia_io::Rights::kReadBytes));
    ASSERT_TRUE(writable->ValidateRights(fuchsia_io::Rights::kWriteBytes));
    ASSERT_FALSE(writable->ValidateRights(fuchsia_io::Rights::kExecute));
  }
}

TEST(VmoFile, Read) {
  zx::vmo abc;
  CreateVmoABC(&abc);

  auto data = std::make_unique<uint8_t[]>(VMO_SIZE);
  memset(data.get(), 0, VMO_SIZE);

  {
    SCOPED_TRACE("empty-read-nonempty-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 0u);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Read(data.get(), 0u, 0u, &actual));
    EXPECT_EQ(0u, actual);
  }

  {
    SCOPED_TRACE("nonempty-read-empty-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 0u);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Read(data.get(), 1u, 0u, &actual));
    EXPECT_EQ(0u, actual);
  }

  {
    SCOPED_TRACE("empty-read-end-of-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 10u);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Read(data.get(), 0u, 10u, &actual));
    EXPECT_EQ(0u, actual);
  }

  {
    SCOPED_TRACE("nonempty-read-end-of-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 10u);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Read(data.get(), 1u, 10u, &actual));
    EXPECT_EQ(0u, actual);
  }

  {
    SCOPED_TRACE("empty-read-beyond-end-of-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 10u);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Read(data.get(), 0u, 11u, &actual));
    EXPECT_EQ(0u, actual);
  }

  {
    SCOPED_TRACE("nonempty-read-beyond-end-of-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 10u);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Read(data.get(), 1u, 11u, &actual));
    EXPECT_EQ(0u, actual);
  }

  {
    SCOPED_TRACE("short-read-nonempty-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 10u);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Read(data.get(), 11u, 1u, &actual));
    EXPECT_EQ(9u, actual);
    CheckData(data.get(), 0u, 9u, 'A');
    CheckData(data.get(), 9u, 1, 0);
  }

  {
    SCOPED_TRACE("full-read");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), VMO_SIZE);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Read(data.get(), VMO_SIZE, 0u, &actual));
    EXPECT_EQ(VMO_SIZE, actual);
    CheckData(data.get(), PAGE_0, zx_system_get_page_size(), 'A');
    CheckData(data.get(), PAGE_1, zx_system_get_page_size(), 'B');
    CheckData(data.get(), PAGE_2, zx_system_get_page_size(), 'C');
  }
}

TEST(VmoFile, Write) {
  zx::vmo abc;
  CreateVmoABC(&abc);

  auto data = std::make_unique<uint8_t[]>(VMO_SIZE);
  memset(data.get(), '!', VMO_SIZE);

  {
    SCOPED_TRACE("empty-write-nonempty-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), zx_system_get_page_size(), true);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Write(data.get(), 0u, 0u, &actual));
    EXPECT_EQ(0u, actual);
    CheckVmo(abc, PAGE_0, zx_system_get_page_size(), 'A');
    CheckVmo(abc, PAGE_1, zx_system_get_page_size(), 'B');
    CheckVmo(abc, PAGE_2, zx_system_get_page_size(), 'C');
  }

  {
    SCOPED_TRACE("nonempty-write-empty-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 0u, true);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_ERR_NO_SPACE, file->Write(data.get(), 1u, 0u, &actual));
  }

  {
    SCOPED_TRACE("empty-write-end-of-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 10u, true);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Write(data.get(), 0u, 10u, &actual));
    EXPECT_EQ(0u, actual);
    CheckVmo(abc, PAGE_0, zx_system_get_page_size(), 'A');
    CheckVmo(abc, PAGE_1, zx_system_get_page_size(), 'B');
    CheckVmo(abc, PAGE_2, zx_system_get_page_size(), 'C');
  }

  {
    SCOPED_TRACE("nonempty-write-end-of-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 10u, true);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_ERR_NO_SPACE, file->Write(data.get(), 1u, 10u, &actual));
  }

  {
    SCOPED_TRACE("empty-write-beyond-end-of-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 10u, true);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Write(data.get(), 0u, 11u, &actual));
    EXPECT_EQ(0u, actual);
    CheckVmo(abc, PAGE_0, zx_system_get_page_size(), 'A');
    CheckVmo(abc, PAGE_1, zx_system_get_page_size(), 'B');
    CheckVmo(abc, PAGE_2, zx_system_get_page_size(), 'C');
  }

  {
    SCOPED_TRACE("nonempty-write-beyond-end-of-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 10u, true);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_ERR_NO_SPACE, file->Write(data.get(), 1u, 11u, &actual));
  }

  {
    SCOPED_TRACE("short-write-nonempty-file");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 10u, true);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Write(data.get(), 11u, 1u, &actual));
    EXPECT_EQ(9u, actual);
    CheckVmo(abc, PAGE_0, 1, 'A');
    CheckVmo(abc, PAGE_0 + 1, 9u, '!');
    CheckVmo(abc, PAGE_0 + 10, zx_system_get_page_size() - 10, 'A');
    CheckVmo(abc, PAGE_1, zx_system_get_page_size(), 'B');
    CheckVmo(abc, PAGE_2, zx_system_get_page_size(), 'C');
  }

  {
    SCOPED_TRACE("full-write");
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), VMO_SIZE, true);
    size_t actual = UINT64_MAX;
    EXPECT_EQ(ZX_OK, file->Write(data.get(), VMO_SIZE, 0u, &actual));
    EXPECT_EQ(VMO_SIZE, actual);
    CheckVmo(abc, 0u, VMO_SIZE, '!');
  }
}

TEST(VmoFile, Getattr) {
  zx::vmo abc;
  CreateVmoABC(&abc);

  // read-only
  {
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file =
        fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), zx_system_get_page_size() * 3u + 117u);
    zx::result attr = file->GetAttributes();
    ASSERT_TRUE(attr.is_ok());
    EXPECT_EQ(zx_system_get_page_size() * 3u + 117u, attr->content_size);
    EXPECT_EQ(4u * zx_system_get_page_size(), attr->storage_size);
  }

  // writable
  {
    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));
    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup),
                                                 zx_system_get_page_size() * 3u + 117u, true);
    zx::result attr = file->GetAttributes();
    ASSERT_TRUE(attr.is_ok());
    EXPECT_EQ(zx_system_get_page_size() * 3u + 117u, attr->content_size);
    EXPECT_EQ(4u * zx_system_get_page_size(), attr->storage_size);
  }
}

TEST(VmoFile, DefaultSharingMode) {
  {
    SCOPED_TRACE("DefaultSharingMode::kDuplicate,read-only");
    zx::vmo abc;
    CreateVmoABC(&abc);

    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));

    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 23u, false,
                                                 fs::VmoFile::DefaultSharingMode::kDuplicate);
    zx::vmo vmo;
    EXPECT_EQ(ZX_OK, file->GetVmo(fuchsia_io::wire::VmoFlags::kRead, &vmo));

    EXPECT_NE(abc.get(), vmo.get());
    EXPECT_EQ(GetKoid(abc.get()), GetKoid(vmo.get()));
    EXPECT_EQ(ZX_RIGHTS_BASIC | ZX_RIGHT_MAP | ZX_RIGHT_GET_PROPERTY | ZX_RIGHT_READ,
              GetRights(vmo.get()));
    uint64_t size;
    EXPECT_EQ(ZX_OK, vmo.get_prop_content_size(&size));
    EXPECT_EQ(VMO_SIZE, size);

    CheckVmo(vmo, PAGE_0, 23u, 'A');
  }

  {
    SCOPED_TRACE("DefaultSharingMode::kDuplicate,read-write");
    zx::vmo abc;
    CreateVmoABC(&abc);

    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));

    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 23u, true,
                                                 fs::VmoFile::DefaultSharingMode::kDuplicate);
    zx::vmo vmo;
    EXPECT_EQ(ZX_OK, file->GetVmo(fuchsia_io::wire::VmoFlags::kRead, &vmo));

    EXPECT_NE(abc.get(), vmo.get());
    EXPECT_EQ(GetKoid(abc.get()), GetKoid(vmo.get()));

    // As the VmoFile implementation does not currently track size changes, we ensure that the
    // handle provided in kDuplicate sharing mode is not writable.
    EXPECT_EQ(ZX_RIGHTS_BASIC | ZX_RIGHT_MAP | ZX_RIGHT_GET_PROPERTY | ZX_RIGHT_READ,
              GetRights(vmo.get()));
    uint64_t size;
    EXPECT_EQ(ZX_OK, vmo.get_prop_content_size(&size));
    EXPECT_EQ(VMO_SIZE, size);

    CheckVmo(vmo, PAGE_0, 23u, 'A');
  }

  {
    SCOPED_TRACE("DefaultSharingMode::kDuplicate,write-only");
    zx::vmo abc;
    CreateVmoABC(&abc);

    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));

    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 23u, true,
                                                 fs::VmoFile::DefaultSharingMode::kDuplicate);
    zx::vmo vmo;
    EXPECT_EQ(ZX_OK, file->GetVmo({}, &vmo));

    EXPECT_NE(abc.get(), vmo.get());
    EXPECT_EQ(GetKoid(abc.get()), GetKoid(vmo.get()));
    // As the VmoFile implementation does not currently track size changes, we ensure that the
    // handle provided in kDuplicate sharing mode is not writable.
    EXPECT_EQ(ZX_RIGHTS_BASIC | ZX_RIGHT_MAP | ZX_RIGHT_GET_PROPERTY, GetRights(vmo.get()));
    uint64_t size;
    EXPECT_EQ(ZX_OK, vmo.get_prop_content_size(&size));
    EXPECT_EQ(VMO_SIZE, size);
  }

  {
    SCOPED_TRACE("DefaultSharingMode::kCloneCow,read-only");
    zx::vmo abc;
    CreateVmoABC(&abc);

    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));

    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 23u, false,
                                                 fs::VmoFile::DefaultSharingMode::kCloneCow);
    zx::vmo vmo;
    // There is non-trivial lazy initialization happening here - repeat it
    // to make sure it's nice and deterministic.
    for (int i = 0; i < 2; i++) {
      EXPECT_EQ(ZX_OK, file->GetVmo(fuchsia_io::wire::VmoFlags::kRead, &vmo));
    }

    EXPECT_NE(abc.get(), vmo.get());
    EXPECT_NE(GetKoid(abc.get()), GetKoid(vmo.get()));
    EXPECT_EQ(ZX_RIGHTS_BASIC | ZX_RIGHT_MAP | ZX_RIGHT_GET_PROPERTY | ZX_RIGHT_READ,
              GetRights(vmo.get()));
    uint64_t size;
    EXPECT_EQ(ZX_OK, vmo.get_prop_content_size(&size));
    EXPECT_EQ(23u, size);

    CheckVmo(vmo, PAGE_0, 23u, 'A');
  }

  {
    SCOPED_TRACE("DefaultSharingMode::kCloneCow,read-write");
    zx::vmo abc;
    CreateVmoABC(&abc);

    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));

    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 23u, true,
                                                 fs::VmoFile::DefaultSharingMode::kCloneCow);
    zx::vmo vmo;
    EXPECT_EQ(
        ZX_OK,
        file->GetVmo(fuchsia_io::wire::VmoFlags::kRead | fuchsia_io::wire::VmoFlags::kWrite, &vmo));

    EXPECT_NE(abc.get(), vmo.get());
    EXPECT_NE(GetKoid(abc.get()), GetKoid(vmo.get()));
    EXPECT_EQ(ZX_RIGHTS_BASIC | ZX_RIGHT_MAP | ZX_RIGHT_GET_PROPERTY | ZX_RIGHT_READ |
                  ZX_RIGHT_WRITE | ZX_RIGHT_SET_PROPERTY,
              GetRights(vmo.get()));
    uint64_t size;
    EXPECT_EQ(ZX_OK, vmo.get_prop_content_size(&size));
    EXPECT_EQ(23u, size);

    FillVmo(vmo, 0, 23u, '!');

    CheckVmo(abc, PAGE_0, zx_system_get_page_size(), 'A');
    CheckVmo(abc, PAGE_1, zx_system_get_page_size(), 'B');
    CheckVmo(abc, PAGE_2, zx_system_get_page_size(), 'C');
  }

  {
    SCOPED_TRACE("DefaultSharingMode::kCloneCow,write-only");
    zx::vmo abc;
    CreateVmoABC(&abc);

    zx::vmo dup;
    ASSERT_EQ(ZX_OK, abc.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup));

    auto file = fbl::MakeRefCounted<fs::VmoFile>(std::move(dup), 23u, true,
                                                 fs::VmoFile::DefaultSharingMode::kCloneCow);
    zx::vmo vmo;
    EXPECT_EQ(ZX_OK, file->GetVmo(fuchsia_io::wire::VmoFlags::kWrite, &vmo));

    EXPECT_NE(abc.get(), vmo.get());
    EXPECT_NE(GetKoid(abc.get()), GetKoid(vmo.get()));
    EXPECT_EQ(ZX_RIGHTS_BASIC | ZX_RIGHT_MAP | ZX_RIGHT_GET_PROPERTY | ZX_RIGHT_WRITE |
                  ZX_RIGHT_SET_PROPERTY,
              GetRights(vmo.get()));
    uint64_t size;
    EXPECT_EQ(ZX_OK, vmo.get_prop_content_size(&size));
    EXPECT_EQ(23u, size);

    FillVmo(vmo, 0, 23u, '!');

    CheckVmo(abc, PAGE_0, zx_system_get_page_size(), 'A');
    CheckVmo(abc, PAGE_1, zx_system_get_page_size(), 'B');
    CheckVmo(abc, PAGE_2, zx_system_get_page_size(), 'C');
  }
}

}  // namespace