| // Copyright 2019 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 "src/storage/fvm/client.h" | |
| #include <zxtest/zxtest.h> | |
| #include "src/storage/lib/block_client/cpp/block_device.h" | |
| namespace fvm { | |
| namespace { | |
| using block_client::BlockDevice; | |
| class MockDeviceBase : public BlockDevice { | |
| public: | |
| ~MockDeviceBase() override = default; | |
| zx_status_t FifoTransaction(BlockFifoRequest* requests, size_t count) final { | |
| return ZX_ERR_NOT_SUPPORTED; | |
| } | |
| zx::result<std::string> GetTopologicalPath() const final { | |
| return zx::error(ZX_ERR_NOT_SUPPORTED); | |
| } | |
| zx::result<> Rebind(std::string_view url_suffix) const override { | |
| return zx::error(ZX_ERR_NOT_SUPPORTED); | |
| } | |
| zx_status_t BlockGetInfo(fuchsia_storage_block::wire::BlockInfo* out_info) const final { | |
| return ZX_ERR_NOT_SUPPORTED; | |
| } | |
| zx_status_t BlockAttachVmo(const zx::vmo& vmo, storage::Vmoid* out_vmoid) final { | |
| return ZX_ERR_NOT_SUPPORTED; | |
| } | |
| zx_status_t VolumeGetInfo(fuchsia_storage_block::wire::VolumeManagerInfo* out_manager, | |
| fuchsia_storage_block::wire::VolumeInfo* out_volume) const final { | |
| return ZX_ERR_NOT_SUPPORTED; | |
| } | |
| zx_status_t VolumeQuerySlices(const uint64_t* slices, size_t slices_count, | |
| fuchsia_storage_block::wire::VsliceRange* out_ranges, | |
| size_t* out_ranges_count) const override { | |
| return ZX_ERR_NOT_SUPPORTED; | |
| } | |
| zx_status_t VolumeExtend(uint64_t offset, uint64_t length) final { return ZX_ERR_NOT_SUPPORTED; } | |
| zx_status_t VolumeShrink(uint64_t offset, uint64_t length) override { | |
| return ZX_ERR_NOT_SUPPORTED; | |
| } | |
| }; | |
| TEST(FvmClientTest, ResetSlicesNotSupported) { | |
| MockDeviceBase device; | |
| ASSERT_EQ(ZX_ERR_NOT_SUPPORTED, ResetAllSlices(&device)); | |
| } | |
| class MockBadDevice : public MockDeviceBase { | |
| public: | |
| zx_status_t VolumeQuerySlices(const uint64_t* slices, size_t slices_count, | |
| fuchsia_storage_block::wire::VsliceRange* out_ranges, | |
| size_t* out_ranges_count) const override { | |
| *out_ranges_count = 0; | |
| return ZX_OK; | |
| } | |
| zx_status_t VolumeShrink(uint64_t offset, uint64_t length) override { return ZX_OK; } | |
| }; | |
| TEST(FvmClientTest, ResetSlicesBadDevice) { | |
| MockBadDevice device; | |
| ASSERT_EQ(ZX_ERR_IO, ResetAllSlices(&device)); | |
| } | |
| // [1, 10]: Allocated | |
| class MockOneSliceRangeDevice : public MockDeviceBase { | |
| public: | |
| zx_status_t VolumeQuerySlices(const uint64_t* slices, size_t slices_count, | |
| fuchsia_storage_block::wire::VsliceRange* out_ranges, | |
| size_t* out_ranges_count) const override { | |
| EXPECT_EQ(1, slices_count); | |
| if (slices[0] == 1) { | |
| out_ranges[0].count = 10; | |
| out_ranges[0].allocated = true; | |
| *out_ranges_count = 1; | |
| return ZX_OK; | |
| } | |
| return ZX_ERR_OUT_OF_RANGE; | |
| } | |
| zx_status_t VolumeShrink(uint64_t offset, uint64_t length) override { | |
| EXPECT_EQ(1, offset); | |
| EXPECT_EQ(10, length); | |
| EXPECT_FALSE(shrink_called_); | |
| shrink_called_ = true; | |
| return ZX_OK; | |
| } | |
| bool shrink_called_ = false; | |
| }; | |
| TEST(FvmClientTest, ResetSlicesOneSliceRange) { | |
| MockOneSliceRangeDevice device; | |
| EXPECT_OK(ResetAllSlices(&device)); | |
| EXPECT_TRUE(device.shrink_called_); | |
| } | |
| // [1, 10]: Allocated | |
| // [11, 20]: Not Allocated | |
| // [21, 30]: Allocated | |
| class MockManySliceRangesDevice : public MockDeviceBase { | |
| public: | |
| zx_status_t VolumeQuerySlices(const uint64_t* slices, size_t slices_count, | |
| fuchsia_storage_block::wire::VsliceRange* out_ranges, | |
| size_t* out_ranges_count) const override { | |
| EXPECT_EQ(1, slices_count); | |
| switch (slices[0]) { | |
| case 1: | |
| out_ranges[0].count = 10; | |
| out_ranges[0].allocated = true; | |
| *out_ranges_count = 1; | |
| return ZX_OK; | |
| case 11: | |
| out_ranges[0].count = 10; | |
| out_ranges[0].allocated = false; | |
| *out_ranges_count = 1; | |
| return ZX_OK; | |
| case 21: | |
| out_ranges[0].count = 10; | |
| out_ranges[0].allocated = true; | |
| *out_ranges_count = 1; | |
| return ZX_OK; | |
| default: | |
| return ZX_ERR_OUT_OF_RANGE; | |
| } | |
| } | |
| zx_status_t VolumeShrink(uint64_t offset, uint64_t length) override { | |
| switch (offset) { | |
| case 1: | |
| EXPECT_EQ(10, length); | |
| EXPECT_FALSE(shrink_called_[0]); | |
| shrink_called_[0] = true; | |
| return ZX_OK; | |
| case 21: | |
| EXPECT_EQ(10, length); | |
| EXPECT_FALSE(shrink_called_[1]); | |
| shrink_called_[1] = true; | |
| return ZX_OK; | |
| default: | |
| return ZX_ERR_IO; | |
| } | |
| } | |
| bool shrink_called_[2] = {}; | |
| }; | |
| TEST(FvmClientTest, ResetSlicesManySliceRanges) { | |
| MockManySliceRangesDevice device; | |
| EXPECT_OK(ResetAllSlices(&device)); | |
| EXPECT_TRUE(device.shrink_called_[0]); | |
| EXPECT_TRUE(device.shrink_called_[1]); | |
| } | |
| } // namespace | |
| } // namespace fvm |