// 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 <blobfs/ring-buffer.h>
#include <blobfs/unbuffered-operations-builder.h>

#include <lib/zx/vmo.h>
#include <zircon/assert.h>
#include <zxtest/zxtest.h>

namespace blobfs {
namespace {

// TODO(smklein): This interface is larger than necessary. Can we reduce it
// to just "attach/detach vmo"?
class MockSpaceManager : public SpaceManager {
public:
    vmoid_t default_vmoid() const {
        return 1;
    }

private:
    const Superblock& Info() const final {
        ZX_ASSERT_MSG(false, "Test should not invoke function: %s\n", __FUNCTION__);
    }
    zx_status_t AttachVmo(const zx::vmo& vmo, vmoid_t* out) override {
        *out = default_vmoid();
        return ZX_OK;
    }
    zx_status_t DetachVmo(vmoid_t vmoid) override {
        EXPECT_EQ(default_vmoid(), vmoid);
        return ZX_OK;
    }
    zx_status_t AddInodes(fzl::ResizeableVmoMapper* node_map) final {
        ZX_ASSERT_MSG(false, "Test should not invoke function: %s\n", __FUNCTION__);
    }
    zx_status_t AddBlocks(size_t nblocks, RawBitmap* block_map) final {
        ZX_ASSERT_MSG(false, "Test should not invoke function: %s\n", __FUNCTION__);
    }
};

TEST(RingBufferTest, EmptyRingBuffer) {
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    EXPECT_EQ(ZX_ERR_INVALID_ARGS, RingBuffer::Create(&space_manager, 0, "test-buffer", &buffer));
}

TEST(RingBufferTest, MakeRingBuffer) {
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    const size_t kBlocks = 5;
    ASSERT_OK(RingBuffer::Create(&space_manager, kBlocks, "test-buffer", &buffer));
    EXPECT_EQ(kBlocks, buffer->capacity());
}

TEST(RingBufferTest, ReserveOne) {
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    const size_t kBlocks = 5;
    ASSERT_OK(RingBuffer::Create(&space_manager, kBlocks, "test-buffer", &buffer));
    RingBufferReservation reservation;
    EXPECT_EQ(0, reservation.length());
    EXPECT_OK(buffer->Reserve(1, &reservation));
    EXPECT_EQ(space_manager.default_vmoid(), reservation.vmoid());
    EXPECT_EQ(0, reservation.start());
    EXPECT_EQ(1, reservation.length());
}

TEST(RingBufferTest, ReserveMove) {
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    const size_t kBlocks = 5;
    ASSERT_OK(RingBuffer::Create(&space_manager, kBlocks, "test-buffer", &buffer));
    RingBufferReservation reservation_a;
    ASSERT_OK(buffer->Reserve(1, &reservation_a));
    EXPECT_EQ(1, reservation_a.length());

    // Move Construction.
    RingBufferReservation reservation_b(std::move(reservation_a));
    EXPECT_EQ(0, reservation_a.length());
    EXPECT_EQ(1, reservation_b.length());

    // Move Assignment.
    reservation_a = std::move(reservation_b);
    EXPECT_EQ(1, reservation_a.length());
    EXPECT_EQ(0, reservation_b.length());
}

TEST(RingBufferTest, ReserveAndFreeOutOfOrder) {
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    const size_t kBlocks = 10;
    ASSERT_OK(RingBuffer::Create(&space_manager, kBlocks, "test-buffer", &buffer));
    RingBufferReservation reservations[4];
    ASSERT_OK(buffer->Reserve(1, &reservations[0]));
    ASSERT_OK(buffer->Reserve(2, &reservations[1]));
    ASSERT_OK(buffer->Reserve(3, &reservations[2]));
    ASSERT_OK(buffer->Reserve(4, &reservations[3]));

    // Although we would ordinarily prefer to free in the order we allocated:
    // 0, 1, 2, 3
    //
    // We will instead free in the following order:
    // 3, 1, 2, 0

    {
        auto unused = std::move(reservations[3]);
    }
    {
        auto unused = std::move(reservations[1]);
    }
    {
        auto unused = std::move(reservations[2]);
    }

    // No space is actually freed until the reservations are freed in-order.
    RingBufferReservation failed_reservation;
    EXPECT_EQ(ZX_ERR_NO_SPACE, buffer->Reserve(1, &failed_reservation));

    {
        auto unused = std::move(reservations[0]);
    }

    // Now ALL the blocks are freed.
    RingBufferReservation reservation;
    EXPECT_OK(buffer->Reserve(kBlocks, &reservation));
}

// Create a test VMO. Write the following pattern to the vmo:
// Block N: value + N
void MakeTestVmo(size_t blocks, int value, zx::vmo* out_vmo) {
    zx::vmo vmo;
    ASSERT_OK(zx::vmo::create(blocks * kBlobfsBlockSize, 0, &vmo));

    uint8_t buf[kBlobfsBlockSize];
    for (size_t i = 0; i < blocks; i++) {
        memset(buf, value++, sizeof(buf));
        ASSERT_OK(vmo.write(buf, i * kBlobfsBlockSize, kBlobfsBlockSize));
    }
    *out_vmo = std::move(vmo);
}

// Check that block |offset| in |vmo| equals |value|.
// Additionally, check that |value| is also set in |addr|.
void CheckVmoEquals(const zx::vmo& vmo, const void* addr, size_t offset, int value) {
    uint8_t buf[kBlobfsBlockSize];
    ASSERT_OK(vmo.read(buf, offset * kBlobfsBlockSize, kBlobfsBlockSize));
    EXPECT_EQ(0, memcmp(buf, addr, kBlobfsBlockSize), "VMO data not equal to addr");
    memset(buf, value, sizeof(buf));
    EXPECT_EQ(0, memcmp(buf, addr, kBlobfsBlockSize), "VMO data not equal to value");
}

// Checks that, for the portion of data accessible in |reservation|, the |operation| is
// accessible at |offset| within the reservation.
void CheckOperationInRingBuffer(const zx::vmo& vmo, RingBufferReservation* reservation,
                                const UnbufferedOperation& operation, size_t offset, int value) {
    for (size_t i = 0; i < operation.op.length; i++) {
        CheckVmoEquals(vmo, reservation->MutableData(i + offset), operation.op.vmo_offset + i,
                       value + static_cast<int>(operation.op.vmo_offset + i));
    }
}

void ReserveAndCopyRequests(const fbl::unique_ptr<RingBuffer>& buffer,
                            fbl::Vector<UnbufferedOperation> requests, RingBufferRequests* out) {
    RingBufferReservation reservation;
    ASSERT_OK(buffer->Reserve(BlockCount(requests), &reservation));
    fbl::Vector<BufferedOperation> buffer_request;
    ASSERT_OK(reservation.CopyRequests(requests, 0, &buffer_request));
    *out = RingBufferRequests(std::move(buffer_request), std::move(reservation));
}

//    VMO: [ A, B, C ]
//    DEV: [ A, B, C ]
// BUFFER: [ A, B, C, _, _ ]
TEST(RingBufferTest, OneRequestAtOffsetZero) {
    zx::vmo vmo;
    const size_t kVmoBlocks = 3;
    int seed = 0xAB;
    MakeTestVmo(kVmoBlocks, seed, &vmo);

    UnbufferedOperationsBuilder builder;
    UnbufferedOperation operation;
    operation.vmo = zx::unowned_vmo(vmo.get());
    operation.op.type = OperationType::kWrite;
    operation.op.vmo_offset = 0;
    operation.op.dev_offset = 0;
    operation.op.length = kVmoBlocks;
    builder.Add(operation);

    const size_t kRingBufferBlocks = 5;
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    ASSERT_OK(RingBuffer::Create(&space_manager, kRingBufferBlocks, "test-buffer", &buffer));

    RingBufferRequests request;
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(), &request));
    ASSERT_EQ(1, request.Operations().size());
    // Start of RingBuffer.
    EXPECT_EQ(0, request.Operations()[0].op.vmo_offset);
    // Same location on dev.
    EXPECT_EQ(operation.op.dev_offset, request.Operations()[0].op.dev_offset);
    // Same length.
    EXPECT_EQ(operation.op.length, request.Operations()[0].op.length);

    EXPECT_EQ(0, request.Reservation()->start());
    EXPECT_EQ(operation.op.length, request.Reservation()->length());
    CheckOperationInRingBuffer(vmo, request.Reservation(), operation, 0, seed);
}

//    VMO: [ _, A, B ]
//    DEV: [ _, _, A, B ]
// BUFFER: [ A, B, _, _, _ ]
TEST(RingBufferTest, OneRequestAtNonZeroOffset) {
    zx::vmo vmo;
    const size_t kVmoBlocks = 3;
    int seed = 0xAB;
    MakeTestVmo(kVmoBlocks, seed, &vmo);

    UnbufferedOperationsBuilder builder;
    UnbufferedOperation operation;
    operation.vmo = zx::unowned_vmo(vmo.get());
    operation.op.type = OperationType::kWrite;
    operation.op.vmo_offset = 1;
    operation.op.dev_offset = 2;
    operation.op.length = kVmoBlocks - operation.op.vmo_offset;
    builder.Add(operation);

    const size_t kRingBufferBlocks = 5;
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    ASSERT_OK(RingBuffer::Create(&space_manager, kRingBufferBlocks, "test-buffer", &buffer));

    RingBufferRequests request;
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(), &request));
    ASSERT_EQ(1, request.Operations().size());
    // Start of RingBuffer.
    EXPECT_EQ(0, request.Operations()[0].op.vmo_offset);
    // Same location on dev.
    EXPECT_EQ(operation.op.dev_offset, request.Operations()[0].op.dev_offset);
    // Same length.
    EXPECT_EQ(operation.op.length, request.Operations()[0].op.length);

    EXPECT_EQ(0, request.Reservation()->start());
    EXPECT_EQ(operation.op.length, request.Reservation()->length());
    CheckOperationInRingBuffer(vmo, request.Reservation(), operation, 0, seed);
}

//  VMO 1: [ A, _, _, _ ]
//  VMO 2: [ _, _, B, C ]
//    DEV: [ _, _, A, _, B, C ]
// BUFFER: [ A, B, C, _, _ ]
TEST(RingBufferTest, TwoRequestsToTheSameVmoSameReservation) {
    zx::vmo vmo;
    const size_t kVmoBlocks = 4;
    int seed = 0xAB;
    MakeTestVmo(kVmoBlocks, seed, &vmo);

    UnbufferedOperationsBuilder builder;
    UnbufferedOperation operations[2];
    operations[0].vmo = zx::unowned_vmo(vmo.get());
    operations[0].op.type = OperationType::kWrite;
    operations[0].op.vmo_offset = 0;
    operations[0].op.dev_offset = 2;
    operations[0].op.length = 1;
    builder.Add(operations[0]);
    operations[1].vmo = zx::unowned_vmo(vmo.get());
    operations[1].op.type = OperationType::kWrite;
    operations[1].op.vmo_offset = 2;
    operations[1].op.dev_offset = 4;
    operations[1].op.length = 2;
    builder.Add(operations[1]);

    const size_t kRingBufferBlocks = 5;
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    ASSERT_OK(RingBuffer::Create(&space_manager, kRingBufferBlocks, "test-buffer", &buffer));

    RingBufferRequests request;
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(), &request));
    ASSERT_EQ(2, request.Operations().size());
    // Start of RingBuffer, and then immediately following the previous request.
    EXPECT_EQ(0, request.Operations()[0].op.vmo_offset);
    EXPECT_EQ(operations[0].op.length, request.Operations()[1].op.vmo_offset);
    // Same location on dev.
    EXPECT_EQ(operations[0].op.dev_offset, request.Operations()[0].op.dev_offset);
    EXPECT_EQ(operations[1].op.dev_offset, request.Operations()[1].op.dev_offset);
    // Same length.
    EXPECT_EQ(operations[0].op.length, request.Operations()[0].op.length);
    EXPECT_EQ(operations[1].op.length, request.Operations()[1].op.length);

    EXPECT_EQ(0, request.Reservation()->start());
    EXPECT_EQ(operations[0].op.length + operations[1].op.length, request.Reservation()->length());
    CheckOperationInRingBuffer(vmo, request.Reservation(), operations[0], 0, seed);
    CheckOperationInRingBuffer(vmo, request.Reservation(), operations[1], operations[0].op.length,
                               seed);
}

//  VMO 1: [ A, _, _, _ ]
//  VMO 2: [ _, _, B, C ]
//    DEV: [ _, _, A, _, B, C ]
// BUFFER: [ A, B, C, _, _ ]
TEST(RingBufferTest, TwoRequestsToTheSameVmoDifferentReservations) {
    zx::vmo vmo;
    const size_t kVmoBlocks = 4;
    int seed = 0xAB;
    MakeTestVmo(kVmoBlocks, seed, &vmo);

    const size_t kRingBufferBlocks = 5;
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    ASSERT_OK(RingBuffer::Create(&space_manager, kRingBufferBlocks, "test-buffer", &buffer));

    UnbufferedOperationsBuilder builder;
    UnbufferedOperation operations[2];
    RingBufferRequests requests[2];
    operations[0].vmo = zx::unowned_vmo(vmo.get());
    operations[0].op.type = OperationType::kWrite;
    operations[0].op.vmo_offset = 0;
    operations[0].op.dev_offset = 2;
    operations[0].op.length = 1;
    builder.Add(operations[0]);
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(),
                                                    &requests[0]));

    operations[1].vmo = zx::unowned_vmo(vmo.get());
    operations[1].op.type = OperationType::kWrite;
    operations[1].op.vmo_offset = 2;
    operations[1].op.dev_offset = 4;
    operations[1].op.length = 2;
    builder.Add(operations[1]);
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(),
                                                    &requests[1]));

    ASSERT_EQ(1, requests[0].Operations().size());
    ASSERT_EQ(1, requests[1].Operations().size());

    // Start of RingBuffer, and then immediately following the previous request.
    EXPECT_EQ(0, requests[0].Operations()[0].op.vmo_offset);
    EXPECT_EQ(operations[0].op.length, requests[1].Operations()[0].op.vmo_offset);
    // Same location on dev.
    EXPECT_EQ(operations[0].op.dev_offset, requests[0].Operations()[0].op.dev_offset);
    EXPECT_EQ(operations[1].op.dev_offset, requests[1].Operations()[0].op.dev_offset);
    // Same length.
    EXPECT_EQ(operations[0].op.length, requests[0].Operations()[0].op.length);
    EXPECT_EQ(operations[1].op.length, requests[1].Operations()[0].op.length);

    EXPECT_EQ(0, requests[0].Reservation()->start());
    EXPECT_EQ(operations[0].op.length, requests[1].Reservation()->start());
    EXPECT_EQ(operations[0].op.length, requests[0].Reservation()->length());
    EXPECT_EQ(operations[1].op.length, requests[1].Reservation()->length());

    CheckOperationInRingBuffer(vmo, requests[0].Reservation(), operations[0], 0, seed);
    CheckOperationInRingBuffer(vmo, requests[1].Reservation(), operations[1], 0, seed);
}

//    VMO: [ A, B, C ]
//    DEV: [ A, B, C ]
// BUFFER: [ A, B, C ]
TEST(RingBufferTest, OneRequestFullRingBuffer) {
    zx::vmo vmo;
    const size_t kVmoBlocks = 3;
    int seed = 0xAB;
    MakeTestVmo(kVmoBlocks, seed, &vmo);

    UnbufferedOperationsBuilder builder;
    UnbufferedOperation operation;
    operation.vmo = zx::unowned_vmo(vmo.get());
    operation.op.type = OperationType::kWrite;
    operation.op.vmo_offset = 0;
    operation.op.dev_offset = 0;
    operation.op.length = kVmoBlocks;
    builder.Add(operation);

    const size_t kRingBufferBlocks = 3;
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    ASSERT_OK(RingBuffer::Create(&space_manager, kRingBufferBlocks, "test-buffer", &buffer));

    RingBufferRequests request;
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(), &request));
    ASSERT_EQ(1, request.Operations().size());
    // Start of RingBuffer.
    EXPECT_EQ(0, request.Operations()[0].op.vmo_offset);
    // Same location on dev.
    EXPECT_EQ(operation.op.dev_offset, request.Operations()[0].op.dev_offset);
    // Same length.
    EXPECT_EQ(operation.op.length, request.Operations()[0].op.length);

    EXPECT_EQ(0, request.Reservation()->start());
    EXPECT_EQ(operation.op.length, request.Reservation()->length());
    CheckOperationInRingBuffer(vmo, request.Reservation(), operation, 0, seed);
}

//    VMO: [ A, B, C, D ]
//    DEV: [ A, B, C, D ]
// BUFFER: [ <Too Small> ]
TEST(RingBufferTest, OneRequestWithRingBufferFull) {
    zx::vmo vmo;
    const size_t kVmoBlocks = 4;
    int seed = 0xAB;
    MakeTestVmo(kVmoBlocks, seed, &vmo);

    UnbufferedOperationsBuilder builder;
    UnbufferedOperation operation;
    operation.vmo = zx::unowned_vmo(vmo.get());
    operation.op.type = OperationType::kWrite;
    operation.op.vmo_offset = 0;
    operation.op.dev_offset = 0;
    operation.op.length = kVmoBlocks;
    builder.Add(operation);

    const size_t kRingBufferBlocks = 3;
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    ASSERT_OK(RingBuffer::Create(&space_manager, kRingBufferBlocks, "test-buffer", &buffer));

    RingBufferRequests request;
    ASSERT_EQ(ZX_ERR_NO_SPACE, buffer->Reserve(BlockCount(builder.TakeOperations()), nullptr));
    ASSERT_EQ(0, request.Operations().size());
}

//  VMO 1: [ A, B, C, _, _, _ ]
//  VMO 2: [ _, _, _, D, E, F ]
//  VMO 3: [ _, _, _, _, _, _, G, H, I ]
//    DEV: [ A, B, C, D, E, F, G, H, I ]
// BUFFER: [ A, B, C, D, E, F ]
// BUFFER: [ <Too Small for third request> ]
// BUFFER: [ _, _, _, D, E, F ]  After completing first request.
// BUFFER: [ G, H, I, D, E, F ]
TEST(RingBufferTest, RingBufferWraparoundCleanly) {
    zx::vmo vmo;
    const size_t kVmoBlocks = 9;
    int seed = 0xAB;
    MakeTestVmo(kVmoBlocks, seed, &vmo);

    const size_t kRingBufferBlocks = 6;
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    ASSERT_OK(RingBuffer::Create(&space_manager, kRingBufferBlocks, "test-buffer", &buffer));

    UnbufferedOperationsBuilder builder;
    UnbufferedOperation operations[3];
    RingBufferRequests requests[3];
    operations[0].vmo = zx::unowned_vmo(vmo.get());
    operations[0].op.type = OperationType::kWrite;
    operations[0].op.vmo_offset = 0;
    operations[0].op.dev_offset = 0;
    operations[0].op.length = 3;
    builder.Add(operations[0]);
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(),
                                                    &requests[0]));

    operations[1].vmo = zx::unowned_vmo(vmo.get());
    operations[1].op.type = OperationType::kWrite;
    operations[1].op.vmo_offset = 3;
    operations[1].op.dev_offset = 3;
    operations[1].op.length = 3;
    builder.Add(operations[1]);
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(),
                                                    &requests[1]));

    operations[2].vmo = zx::unowned_vmo(vmo.get());
    operations[2].op.type = OperationType::kWrite;
    operations[2].op.vmo_offset = 6;
    operations[2].op.dev_offset = 6;
    operations[2].op.length = 3;
    builder.Add(operations[2]);
    ASSERT_EQ(ZX_ERR_NO_SPACE, buffer->Reserve(BlockCount(builder.TakeOperations()), nullptr));

    CheckOperationInRingBuffer(vmo, requests[0].Reservation(), operations[0], 0, seed);
    CheckOperationInRingBuffer(vmo, requests[1].Reservation(), operations[1], 0, seed);

    // Releasing the first request makes enough room in the buffer.
    {
        auto released = std::move(requests[0]);
    }
    builder.Add(operations[2]);
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(),
                                                    &requests[2]));
    CheckOperationInRingBuffer(vmo, requests[1].Reservation(), operations[1], 0, seed);
    CheckOperationInRingBuffer(vmo, requests[2].Reservation(), operations[2], 0, seed);
}

//  VMO 1: [ A, B, C, _, _, _ ]
//  VMO 2: [ _, _, _, _, D, _, _ ]
//  VMO 3: [ _, _, _, _, _, _, E, F, G, H, I]
//    DEV: [ A, B, C, _, D, _, E, F, G, H, I]
// BUFFER: [ A, B, C, D, _, _ ]
// BUFFER: [ _, _, _, D, _, _ ]  After completing first request.
// BUFFER: [ G, H, I, D, E, F ]
TEST(RingBufferTest, RingBufferWraparoundSplitRequest) {
    zx::vmo vmo;
    const size_t kVmoBlocks = 11;
    int seed = 0xAB;
    MakeTestVmo(kVmoBlocks, seed, &vmo);

    const size_t kRingBufferBlocks = 6;
    MockSpaceManager space_manager;
    std::unique_ptr<RingBuffer> buffer;
    ASSERT_OK(RingBuffer::Create(&space_manager, kRingBufferBlocks, "test-buffer", &buffer));

    UnbufferedOperationsBuilder builder;
    UnbufferedOperation operations[3];
    RingBufferRequests requests[3];
    operations[0].vmo = zx::unowned_vmo(vmo.get());
    operations[0].op.type = OperationType::kWrite;
    operations[0].op.vmo_offset = 0;
    operations[0].op.dev_offset = 0;
    operations[0].op.length = 3;
    builder.Add(operations[0]);
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(),
                                                    &requests[0]));

    operations[1].vmo = zx::unowned_vmo(vmo.get());
    operations[1].op.type = OperationType::kWrite;
    operations[1].op.vmo_offset = 4;
    operations[1].op.dev_offset = 4;
    operations[1].op.length = 1;
    builder.Add(operations[1]);
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(),
                                                    &requests[1]));

    operations[2].vmo = zx::unowned_vmo(vmo.get());
    operations[2].op.type = OperationType::kWrite;
    operations[2].op.vmo_offset = 6;
    operations[2].op.dev_offset = 6;
    operations[2].op.length = 5;
    builder.Add(operations[2]);
    ASSERT_EQ(ZX_ERR_NO_SPACE, buffer->Reserve(BlockCount(builder.TakeOperations()), nullptr));

    CheckOperationInRingBuffer(vmo, requests[0].Reservation(), operations[0], 0, seed);
    CheckOperationInRingBuffer(vmo, requests[1].Reservation(), operations[1], 0, seed);

    // Releasing the first request makes enough room in the buffer.
    {
        auto released = std::move(requests[0]);
    }
    builder.Add(operations[2]);
    ASSERT_NO_FATAL_FAILURES(ReserveAndCopyRequests(buffer, builder.TakeOperations(),
                                                    &requests[2]));
    CheckOperationInRingBuffer(vmo, requests[1].Reservation(), operations[1], 0, seed);
    CheckOperationInRingBuffer(vmo, requests[2].Reservation(), operations[2], 0, seed);
}

// Tests copying requests at an offset, where the offset wraps around the ring buffer.
//
// RESERVATION 1: [ A, B, _, _ ]
// RESERVATION 2: [ _, _, C, _ ]
// RESERVATION 3: [ _, _, _, D ]
//   RING-BUFFER: [ A, B, C, _ ]
//   RING-BUFFER: [ _, _, C, _ ] After releasing first request.
//   RING-BUFFER: [ _, D, C, _ ] Writing "VMO 3" at an offset within the reservation.
TEST(RingBufferTest, CopyRequestAtOffsetWraparound) {
    zx::vmo vmo;
    const size_t kVmoBlocks = 4;
    int seed = 0xAB;
    MakeTestVmo(kVmoBlocks, seed, &vmo);

    const size_t kRingBufferBlocks = 4;
    MockSpaceManager space_manager;
    VmoBuffer vmo_buffer;
    ASSERT_OK(vmo_buffer.Initialize(&space_manager, kRingBufferBlocks, "test-buffer"));
    auto buffer = std::make_unique<RingBuffer>(std::move(vmo_buffer));

    RingBufferReservation reservations[3];
    ASSERT_OK(buffer->Reserve(2, &reservations[0]));
    ASSERT_OK(buffer->Reserve(1, &reservations[1]));

    UnbufferedOperationsBuilder builder;
    UnbufferedOperation operations[3];

    // "A, B"
    operations[0].vmo = zx::unowned_vmo(vmo.get());
    operations[0].op.type = OperationType::kWrite;
    operations[0].op.vmo_offset = 0;
    operations[0].op.dev_offset = 0;
    operations[0].op.length = 2;
    builder.Add(operations[0]);
    fbl::Vector<BufferedOperation> buffer_operation;
    ASSERT_OK(reservations[0].CopyRequests(builder.TakeOperations(), 0, &buffer_operation));

    // "C"
    operations[1].vmo = zx::unowned_vmo(vmo.get());
    operations[1].op.type = OperationType::kWrite;
    operations[1].op.vmo_offset = 2;
    operations[1].op.dev_offset = 2;
    operations[1].op.length = 1;
    builder.Add(operations[1]);
    ASSERT_OK(reservations[1].CopyRequests(builder.TakeOperations(), 0, &buffer_operation));

    ASSERT_NO_FATAL_FAILURES(CheckVmoEquals(vmo, reservations[0].MutableData(0), 0, seed));
    ASSERT_NO_FATAL_FAILURES(CheckVmoEquals(vmo, reservations[1].MutableData(0), 2, seed + 2));

    ASSERT_EQ(ZX_ERR_NO_SPACE, buffer->Reserve(3, &reservations[2]));
    {
        auto released = std::move(reservations[0]);
    }
    ASSERT_OK(buffer->Reserve(3, &reservations[2]));

    // "D"
    operations[2].vmo = zx::unowned_vmo(vmo.get());
    operations[2].op.type = OperationType::kWrite;
    operations[2].op.vmo_offset = 3;
    operations[2].op.dev_offset = 3;
    operations[2].op.length = 1;
    builder.Add(operations[2]);

    const size_t reservation_offset = 2;
    ASSERT_OK(reservations[2].CopyRequests(builder.TakeOperations(), reservation_offset,
                                           &buffer_operation));

    ASSERT_NO_FATAL_FAILURES(CheckVmoEquals(vmo, reservations[1].MutableData(0), 2, seed + 2));
    ASSERT_NO_FATAL_FAILURES(CheckVmoEquals(vmo, reservations[2].MutableData(reservation_offset),
                                            3, seed + 3));
}

// Tests manually adding header and footer around a payload.
//
//       VMO 1: [ A, _, C ] (Copied into buffer via MutableData)
//       VMO 2: [ _, B, _ ] (Copied into buffer via CopyRequests)
//  VMO-BUFFER: [ A, B, C ]
//         DEV: [ A, B, C ]
// RING-BUFFER: [ A, B, C ]
TEST(RingBufferTest, CopyRequestAtOffsetWithHeaderAndFooter) {
    zx::vmo vmo_a, vmo_b;
    const size_t kVmoBlocks = 3;
    int seed_a = 0xAB;
    MakeTestVmo(kVmoBlocks, seed_a, &vmo_a);
    int seed_b = 0xCD;
    MakeTestVmo(kVmoBlocks, seed_b, &vmo_b);

    const size_t kRingBufferBlocks = 5;
    MockSpaceManager space_manager;
    VmoBuffer vmo_buffer;
    ASSERT_OK(vmo_buffer.Initialize(&space_manager, kRingBufferBlocks, "test-buffer"));
    auto buffer = std::make_unique<RingBuffer>(std::move(vmo_buffer));

    RingBufferReservation reservation;
    ASSERT_OK(buffer->Reserve(3, &reservation));
    // Write header from source VMO into reservation.
    ASSERT_OK(vmo_a.read(reservation.MutableData(0), 0, kBlobfsBlockSize));
    // Write footer.
    ASSERT_OK(vmo_a.read(reservation.MutableData(2), 2 * kBlobfsBlockSize, kBlobfsBlockSize));

    // Data "B" of the VMO.
    UnbufferedOperationsBuilder builder;
    UnbufferedOperation operation;
    operation.vmo = zx::unowned_vmo(vmo_b.get());
    operation.op.type = OperationType::kWrite;
    operation.op.vmo_offset = 1;
    operation.op.dev_offset = 1;
    operation.op.length = 1;
    builder.Add(operation);
    fbl::Vector<BufferedOperation> buffer_operation;
    ASSERT_OK(reservation.CopyRequests(builder.TakeOperations(), 1, &buffer_operation));
    ASSERT_EQ(1, buffer_operation.size());
    ASSERT_EQ(1, buffer_operation[0].op.vmo_offset);
    ASSERT_EQ(1, buffer_operation[0].op.dev_offset);
    ASSERT_EQ(1, buffer_operation[0].op.length);

    ASSERT_NO_FATAL_FAILURES(CheckVmoEquals(vmo_a, reservation.MutableData(0), 0, seed_a));
    ASSERT_NO_FATAL_FAILURES(CheckVmoEquals(vmo_b, reservation.MutableData(1), 1, seed_b + 1));
    ASSERT_NO_FATAL_FAILURES(CheckVmoEquals(vmo_a, reservation.MutableData(2), 2, seed_a + 2));
}

} // namespace
} // namespace blobfs