// Copyright 2019 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include <memory>
#include <tuple>
#include <utility>

#include "dawn/common/StringViewUtils.h"
#include "dawn/tests/MockCallback.h"
#include "dawn/tests/ParamGenerator.h"
#include "dawn/tests/StringViewMatchers.h"
#include "dawn/tests/unittests/wire/WireTest.h"
#include "dawn/wire/client/ClientMemoryTransferService_mock.h"
#include "dawn/wire/server/ServerMemoryTransferService_mock.h"

namespace wgpu {
// Define a stream operator for wgpu::MapMode so that it can be found on resolution for test name
// generation.
// TODO(dawn:2205) Remove this in favor of custom serializer.
static std::ostream& operator<<(std::ostream& os, const MapMode& param) {
    switch (param) {
        case wgpu::MapMode::Read:
            os << "Read";
            break;
        case wgpu::MapMode::Write:
            os << "Write";
            break;
        default:
            DAWN_UNREACHABLE();
    }
    return os;
}
}  // namespace wgpu

namespace dawn::wire {
namespace {

using testing::_;
using testing::InvokeWithoutArgs;
using testing::MockCppCallback;
using testing::Ne;
using testing::NotNull;
using testing::Return;
using testing::SizedString;
using testing::StrictMock;
using testing::WithArg;

using MapMode = wgpu::MapMode;
using MappedAtCreation = bool;
DAWN_TEST_PARAM_STRUCT_TYPES(MapModeParam, MapMode, MappedAtCreation);

MATCHER_P(AsUint32Eq, value, "") {
    return *reinterpret_cast<const uint32_t*>(arg) == value;
}

using MockClientReadHandle = client::MockMemoryTransferService::MockReadHandle;
using MockClientWriteHandle = client::MockMemoryTransferService::MockWriteHandle;
using MockServerReadHandle = server::MockMemoryTransferService::MockReadHandle;
using MockServerWriteHandle = server::MockMemoryTransferService::MockWriteHandle;
using MockClientHandles = std::tuple<MockClientReadHandle*, MockClientWriteHandle*>;
using MockServerHandles = std::tuple<MockServerReadHandle*, MockServerWriteHandle*>;

// WireMemoryTransferServiceTests test the MemoryTransferService with buffer mapping.
// They test the basic success and error cases for buffer mapping, and they test
// mocked failures of each fallible MemoryTransferService method that an embedder
// could implement.
// The test harness defines multiple helpers for expecting operations on Read/Write handles
// and for mocking failures.
// There are tests which check for Success for every mapping operation which mock an entire
// mapping operation from map to unmap, and add all MemoryTransferService expectations. Tests
// which check for errors perform the same mapping operations but insert mocked failures for
// various mapping or MemoryTransferService operations.
class WireMemoryTransferServiceTestBase : public WireTest,
                                          public testing::WithParamInterface<MapModeParam> {
  protected:
    client::MemoryTransferService* GetClientMemoryTransferService() override { return &mClientMTS; }
    server::MemoryTransferService* GetServerMemoryTransferService() override { return &mServerMTS; }

    wgpu::BufferUsage GetUsage() {
        switch (GetParam().mMapMode) {
            case wgpu::MapMode::Read:
                return wgpu::BufferUsage::MapRead;
            case wgpu::MapMode::Write:
                return wgpu::BufferUsage::MapWrite;
            default:
                DAWN_UNREACHABLE();
        }
    }

    std::pair<WGPUBuffer, wgpu::Buffer> CreateBuffer() {
        wgpu::BufferUsage usage = GetUsage();
        bool mappedAtCreation = GetParam().mMappedAtCreation;

        wgpu::BufferDescriptor descriptor = {};
        descriptor.size = kBufferSize;
        descriptor.mappedAtCreation = mappedAtCreation;
        descriptor.usage = usage;

        WGPUBuffer apiBuffer = api.GetNewBuffer();
        wgpu::Buffer buffer = device.CreateBuffer(&descriptor);
        EXPECT_CALL(api, DeviceCreateBuffer(apiDevice, _)).WillOnce(Return(apiBuffer));

        return std::make_pair(apiBuffer, buffer);
    }

    std::tuple<WGPUBuffer, wgpu::Buffer, MockClientHandles, MockServerHandles> CreateValidBuffer() {
        WGPUBuffer apiBuffer;
        wgpu::Buffer buffer;

        // The client should create and serialize the appropriate handles on buffer creation.
        auto clientHandles = ExpectHandleCreation(true);
        ExpectHandleSerialization(clientHandles);
        std::tie(apiBuffer, buffer) = CreateBuffer();

        // When the commands are flushed, the server should appropriately deserialize the handles.
        auto serverHandles = ExpectHandleDeserialization(true);
        if (GetParam().mMappedAtCreation) {
            EXPECT_CALL(api, BufferGetMappedRange(apiBuffer, 0, kBufferSize))
                .WillOnce(Return(&mServerBufferContent));
        }
        FlushClient();

        return std::make_tuple(apiBuffer, buffer, clientHandles, serverHandles);
    }

    MockClientHandles ExpectHandleCreation(bool success) {
        wgpu::MapMode mode = GetParam().mMapMode;
        bool mappedAtCreation = GetParam().mMappedAtCreation;
        switch (mode) {
            case wgpu::MapMode::Read: {
                auto* readHandle = success ? new StrictMock<MockClientReadHandle>() : nullptr;
                EXPECT_CALL(mClientMTS, CreateReadHandle(kBufferSize)).WillOnce(Return(readHandle));
                if (!success) {
                    return std::make_tuple(nullptr, nullptr);
                }
                if (mappedAtCreation) {
                    auto* writeHandle = new StrictMock<MockClientWriteHandle>();
                    EXPECT_CALL(mClientMTS, CreateWriteHandle(kBufferSize))
                        .WillOnce(Return(writeHandle));
                    EXPECT_CALL(*writeHandle, GetData).WillOnce(Return(&mClientBufferContent));
                    return std::make_tuple(readHandle, writeHandle);
                }
                return std::make_tuple(readHandle, nullptr);
            }
            case wgpu::MapMode::Write: {
                auto* writeHandle = success ? new StrictMock<MockClientWriteHandle>() : nullptr;
                EXPECT_CALL(mClientMTS, CreateWriteHandle(kBufferSize))
                    .WillOnce(Return(writeHandle));
                if (!success) {
                    return std::make_tuple(nullptr, nullptr);
                }
                if (mappedAtCreation) {
                    EXPECT_CALL(*writeHandle, GetData).WillOnce(Return(&mClientBufferContent));
                }
                return std::make_tuple(nullptr, writeHandle);
            }
            default:
                DAWN_UNREACHABLE();
        }
    }

    void ExpectHandleSerialization(MockClientHandles& clientHandles) {
        auto* readHandle = std::get<MockClientReadHandle*>(clientHandles);
        if (readHandle) {
            EXPECT_CALL(*readHandle, SerializeCreateSize).WillOnce(InvokeWithoutArgs([&] {
                return sizeof(mSerializeCreateInfo);
            }));
            EXPECT_CALL(*readHandle, SerializeCreate(_))
                .WillOnce(WithArg<0>([&](void* serializePointer) {
                    memcpy(serializePointer, &mSerializeCreateInfo, kDataSize);
                    return kDataSize;
                }));
        }
        auto* writeHandle = std::get<MockClientWriteHandle*>(clientHandles);
        if (writeHandle) {
            EXPECT_CALL(*writeHandle, SerializeCreateSize).WillOnce(InvokeWithoutArgs([&] {
                return sizeof(mSerializeCreateInfo);
            }));
            EXPECT_CALL(*writeHandle, SerializeCreate(_))
                .WillOnce(WithArg<0>([&](void* serializePointer) {
                    memcpy(serializePointer, &mSerializeCreateInfo, kDataSize);
                    return kDataSize;
                }));
        }
    }

    MockServerHandles ExpectHandleDeserialization(bool success) {
        wgpu::MapMode mode = GetParam().mMapMode;
        bool mappedAtCreation = GetParam().mMappedAtCreation;
        switch (mode) {
            case wgpu::MapMode::Read: {
                MockServerWriteHandle* writeHandle = nullptr;
                if (mappedAtCreation) {
                    writeHandle = success ? new StrictMock<MockServerWriteHandle>() : nullptr;
                    EXPECT_CALL(mServerMTS, DeserializeWriteHandle(AsUint32Eq(mSerializeCreateInfo),
                                                                   kDataSize, _))
                        .WillOnce(
                            WithArg<2>([=](server::MemoryTransferService::WriteHandle** handle) {
                                *handle = writeHandle;
                                return success;
                            }));
                    if (!success) {
                        return std::make_tuple(nullptr, nullptr);
                    }
                }

                auto* readHandle = success ? new StrictMock<MockServerReadHandle>() : nullptr;
                EXPECT_CALL(mServerMTS,
                            DeserializeReadHandle(AsUint32Eq(mSerializeCreateInfo), kDataSize, _))
                    .WillOnce(WithArg<2>([=](server::MemoryTransferService::ReadHandle** handle) {
                        *handle = readHandle;
                        return success;
                    }));
                return std::make_tuple(readHandle, writeHandle);
            }
            case wgpu::MapMode::Write: {
                auto* writeHandle = success ? new StrictMock<MockServerWriteHandle>() : nullptr;
                EXPECT_CALL(mServerMTS,
                            DeserializeWriteHandle(AsUint32Eq(mSerializeCreateInfo), kDataSize, _))
                    .WillOnce(WithArg<2>([=](server::MemoryTransferService::WriteHandle** handle) {
                        *handle = writeHandle;
                        return success;
                    }));
                return std::make_tuple(nullptr, writeHandle);
            }
            default:
                DAWN_UNREACHABLE();
        }
    }

    void ExpectClientSerializeData(MockClientHandles& clientHandles) {
        auto* clientHandle = std::get<MockClientWriteHandle*>(clientHandles);
        if (!clientHandle) {
            return;
        }

        EXPECT_CALL(*clientHandle, SizeOfSerializeDataUpdate(_, _)).WillOnce(Return(kDataSize));
        EXPECT_CALL(*clientHandle, SerializeDataUpdate)
            .WillOnce(WithArg<0>([&](void* serializePointer) {
                memcpy(serializePointer, &mClientBufferContent, kBufferSize);
            }));
    }
    void ExpectServerSerializeData(MockServerHandles& serverHandles) {
        auto* serverHandle = std::get<MockServerReadHandle*>(serverHandles);
        if (!serverHandle) {
            return;
        }

        EXPECT_CALL(*serverHandle, SizeOfSerializeDataUpdate(_, _)).WillOnce(Return(kDataSize));
        EXPECT_CALL(*serverHandle, SerializeDataUpdate)
            .WillOnce(WithArg<3>([&](void* serializePointer) {
                memcpy(serializePointer, &mServerBufferContent, kBufferSize);
                return kBufferSize;
            }));
    }

    void ExpectClientDeserializeData(bool success, MockClientHandles& clientHandles) {
        auto* clientHandle = std::get<MockClientReadHandle*>(clientHandles);
        if (!clientHandle) {
            return;
        }

        EXPECT_CALL(*clientHandle, DeserializeDataUpdate(_, kBufferSize, 0, kBufferSize))
            .WillOnce(WithArg<0>([&, success](const void* deserializePointer) {
                if (success) {
                    // Copy the data manually here.
                    memcpy(&mClientBufferContent, deserializePointer, kBufferSize);
                }
                return success;
            }));
    }
    void ExpectServerDeserializeData(bool success, MockServerHandles& serverHandles) {
        auto* serverHandle = std::get<MockServerWriteHandle*>(serverHandles);
        if (!serverHandle) {
            return;
        }

        EXPECT_CALL(*serverHandle, DeserializeDataUpdate(_, kBufferSize, 0, kBufferSize))
            .WillOnce(WithArg<0>([&, success](const void* deserializePointer) {
                if (success) {
                    // Copy the data manually here.
                    memcpy(&mServerBufferContent, deserializePointer, kBufferSize);
                }
                return success;
            }));
    }

    void ExpectClientHandleDestruction(MockClientHandles& clientHandles) {
        auto* readHandle = std::get<MockClientReadHandle*>(clientHandles);
        if (readHandle) {
            EXPECT_CALL(*readHandle, Destroy).Times(1);
        }
        auto* writeHandle = std::get<MockClientWriteHandle*>(clientHandles);
        if (writeHandle) {
            EXPECT_CALL(*writeHandle, Destroy).Times(1);
        }
    }
    void ExpectServerHandleDestruction(MockServerHandles& serverHandles) {
        auto* readHandle = std::get<MockServerReadHandle*>(serverHandles);
        if (readHandle) {
            EXPECT_CALL(*readHandle, Destroy).Times(1);
        }
        auto* writeHandle = std::get<MockServerWriteHandle*>(serverHandles);
        if (writeHandle) {
            EXPECT_CALL(*writeHandle, Destroy).Times(1);
        }
    }

    // Sets expectations for a successful map async call and verifies that the results match for the
    // MapMode.
    void ExpectSuccessfulMapAsync(WGPUBuffer apiBuffer,
                                  wgpu::Buffer buffer,
                                  MockClientHandles& clientHandles,
                                  MockServerHandles& serverHandles) {
        wgpu::MapMode mode = GetParam().mMapMode;

        // Mode independent expectations.
        EXPECT_CALL(api,
                    OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mode), 0, kBufferSize, _))
            .WillOnce(InvokeWithoutArgs([&] {
                api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
                                               kEmptyOutputStringView);
            }));
        EXPECT_CALL(mMapAsyncCb, Call(wgpu::MapAsyncStatus::Success, _)).Times(1);

        switch (mode) {
            case wgpu::MapMode::Read: {
                auto* clientHandle = std::get<MockClientReadHandle*>(clientHandles);
                ASSERT_THAT(clientHandle, NotNull());
                EXPECT_CALL(*clientHandle, GetData).WillOnce(Return(&mClientBufferContent));
                EXPECT_CALL(api, BufferGetConstMappedRange(apiBuffer, 0, kBufferSize))
                    .WillOnce(Return(&mServerBufferContent));

                buffer.MapAsync(mode, 0, kBufferSize, wgpu::CallbackMode::AllowSpontaneous,
                                mMapAsyncCb.Callback());

                // The server should serialize its buffer when the client flushes.
                ExpectServerSerializeData(serverHandles);
                FlushClient();

                // The client should deserialize into its buffer when the server flushes.
                ExpectClientDeserializeData(true, clientHandles);
                FlushServer();

                // The data between the server and the client should be the same now.
                EXPECT_EQ(mServerBufferContent, mClientBufferContent);
                break;
            }
            case wgpu::MapMode::Write: {
                auto* clientHandle = std::get<MockClientWriteHandle*>(clientHandles);
                ASSERT_THAT(clientHandle, NotNull());
                EXPECT_CALL(*clientHandle, GetData).WillOnce(Return(&mClientBufferContent));
                EXPECT_CALL(api, BufferGetMappedRange(apiBuffer, 0, kBufferSize))
                    .WillOnce(Return(&mClientBufferContent));

                buffer.MapAsync(mode, 0, kBufferSize, wgpu::CallbackMode::AllowSpontaneous,
                                mMapAsyncCb.Callback());
                FlushClient();
                FlushServer();
                break;
            }
            default:
                DAWN_UNREACHABLE();
        }
    }

    // Note that we pass in the mode explicitly here to allow reuse for mappedAtCreation.
    void ExpectSuccessfulUnmap(wgpu::MapMode mode,
                               WGPUBuffer apiBuffer,
                               wgpu::Buffer buffer,
                               MockClientHandles& clientHandles,
                               MockServerHandles& serverHandles) {
        switch (mode) {
            case wgpu::MapMode::Read: {
                // Unmap the buffer.
                buffer.Unmap();
                EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
                FlushClient();
                break;
            }
            case wgpu::MapMode::Write: {
                // The client should serialize its buffer when Unmap is called.
                ExpectClientSerializeData(clientHandles);
                buffer.Unmap();

                // The server should deserialize into its buffer when the client flushes.
                EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
                ExpectServerDeserializeData(true, serverHandles);
                FlushClient();

                // The data between the server and the client should be the same now.
                EXPECT_EQ(mServerBufferContent, mClientBufferContent);
                break;
            }
            default:
                DAWN_UNREACHABLE();
        }
    }

    void ExpectSuccessfulUnmapAtCreation(WGPUBuffer apiBuffer,
                                         wgpu::Buffer buffer,
                                         MockClientHandles& clientHandles,
                                         MockServerHandles& serverHandles) {
        ASSERT_TRUE(GetParam().mMappedAtCreation);

        // Ensure that the contents on the client and server side are different now as a part of the
        // test.
        mClientBufferContent = kDataGenerator++;
        mServerBufferContent = kDataGenerator++;
        ASSERT_THAT(mClientBufferContent, Ne(mServerBufferContent));

        // If the map mode of the buffer was actually MapRead, we should expect destruction of the
        // WriteHandles, and setting the ReadHandles instead.
        bool isRead = GetParam().mMapMode == wgpu::MapMode::Read;
        if (isRead) {
            auto* clientWriteHandle = std::get<MockClientWriteHandle*>(clientHandles);
            ASSERT_THAT(clientWriteHandle, NotNull());
            EXPECT_CALL(*clientWriteHandle, Destroy).Times(1);
            auto* clientReadHandle = std::get<MockClientReadHandle*>(clientHandles);
            ASSERT_THAT(clientReadHandle, NotNull());
            EXPECT_CALL(*clientReadHandle, GetData).WillOnce(Return(&mClientBufferContent));

            auto* serverHandle = std::get<MockServerWriteHandle*>(serverHandles);
            ASSERT_THAT(serverHandle, NotNull());
            EXPECT_CALL(*serverHandle, Destroy).Times(1);
        }

        ExpectSuccessfulUnmap(wgpu::MapMode::Write, apiBuffer, buffer, clientHandles,
                              serverHandles);

        // Update the handles accordingly if we are MapRead.
        if (isRead) {
            clientHandles =
                std::make_tuple(std::get<MockClientReadHandle*>(clientHandles), nullptr);
            serverHandles =
                std::make_tuple(std::get<MockServerReadHandle*>(serverHandles), nullptr);
        }
    }

    // Static atomic that's used to generate different values across tests.
    static std::atomic<uint32_t> kDataGenerator;

    uint32_t mClientBufferContent = 0;
    uint32_t mServerBufferContent = 0;
    static constexpr size_t kBufferSize = sizeof(uint32_t);

    uint32_t mSerializeCreateInfo = kDataGenerator++;
    static constexpr size_t kDataSize = sizeof(uint32_t);

    StrictMock<MockCppCallback<wgpu::BufferMapCallback<void>*>> mMapAsyncCb;

    StrictMock<wire::server::MockMemoryTransferService> mServerMTS;
    StrictMock<wire::client::MockMemoryTransferService> mClientMTS;
};
std::atomic<uint32_t> WireMemoryTransferServiceTestBase::kDataGenerator = 1337;

class WireMemoryTransferServiceBufferHandleTests : public WireMemoryTransferServiceTestBase {};
INSTANTIATE_TEST_SUITE_P(
    ,
    WireMemoryTransferServiceBufferHandleTests,
    testing::ValuesIn(ParamGenerator<WireMemoryTransferServiceBufferHandleTests::ParamType,
                                     MapMode,
                                     MappedAtCreation>({wgpu::MapMode::Read, wgpu::MapMode::Write},
                                                       {true, false})),
    &TestParamToString<WireMemoryTransferServiceBufferHandleTests::ParamType>);

// Test handle(s) destroy behavior.
TEST_P(WireMemoryTransferServiceBufferHandleTests, Destroy) {
    WGPUBuffer apiBuffer;
    wgpu::Buffer buffer;
    MockClientHandles clientHandles;
    MockServerHandles serverHandles;
    std::tie(apiBuffer, buffer, clientHandles, serverHandles) = CreateValidBuffer();

    // The client handles are destroyed on buffer.Destroy().
    ExpectClientHandleDestruction(clientHandles);
    buffer.Destroy();

    // The server handles are destroyed when the destroy command is flushed.
    ExpectServerHandleDestruction(serverHandles);
    EXPECT_CALL(api, BufferDestroy(apiBuffer)).Times(1);
    FlushClient();

    // Releasing the buffer should be reflected on the server when flushed.
    buffer = nullptr;
    EXPECT_CALL(api, BufferRelease(apiBuffer)).Times(1);
    FlushClient();
}

// Test handle(s) creation failure.
TEST_P(WireMemoryTransferServiceBufferHandleTests, CreationFailure) {
    ExpectHandleCreation(false);

    wgpu::BufferDescriptor descriptor = {};
    descriptor.size = kBufferSize;
    descriptor.usage = GetUsage();

    WGPUBuffer apiErrorBuffer = api.GetNewBuffer();
    wgpu::Buffer errorBuffer = device.CreateBuffer(&descriptor);
    EXPECT_CALL(api, DeviceCreateErrorBuffer(apiDevice, _)).WillOnce(Return(apiErrorBuffer));
    FlushClient();

    // Releasing the buffer should be reflected on the server when flushed.
    errorBuffer = nullptr;
    EXPECT_CALL(api, BufferRelease(apiErrorBuffer)).Times(1);
    FlushClient();
}

// Test handle(s) deserialization (only the handles across the wire, not the data) failure.
TEST_P(WireMemoryTransferServiceBufferHandleTests, DeserializationFailure) {
    WGPUBuffer apiBuffer;
    wgpu::Buffer buffer;

    // The client should create and serialize the appropriate handles on buffer creation.
    auto clientHandles = ExpectHandleCreation(true);
    ExpectHandleSerialization(clientHandles);
    std::tie(apiBuffer, buffer) = CreateBuffer();

    // When the commands are flushed, mock that the server fails to deserialize the handle.
    ExpectHandleDeserialization(false);
    FlushClient(false);

    // The client handles are destroyed when the buffer is released.
    ExpectClientHandleDestruction(clientHandles);
    buffer = nullptr;

    // Releasing the buffer should be reflected on the server when flushed.
    EXPECT_CALL(api, BufferRelease(apiBuffer)).Times(1);
    FlushClient();
}

class WireMemoryTransferServiceBufferMapAsyncTests : public WireMemoryTransferServiceTestBase {};
INSTANTIATE_TEST_SUITE_P(
    ,
    WireMemoryTransferServiceBufferMapAsyncTests,
    testing::ValuesIn(ParamGenerator<WireMemoryTransferServiceBufferMapAsyncTests::ParamType,
                                     MapMode,
                                     MappedAtCreation>({wgpu::MapMode::Read, wgpu::MapMode::Write},
                                                       {true, false})),
    &TestParamToString<WireMemoryTransferServiceBufferMapAsyncTests::ParamType>);

// Test successful mapping.
TEST_P(WireMemoryTransferServiceBufferMapAsyncTests, Success) {
    WGPUBuffer apiBuffer;
    wgpu::Buffer buffer;
    MockClientHandles clientHandles;
    MockServerHandles serverHandles;
    std::tie(apiBuffer, buffer, clientHandles, serverHandles) = CreateValidBuffer();

    // If we were mappedAtCreation, successfully handle that initial unmapping now.
    if (GetParam().mMappedAtCreation) {
        ExpectSuccessfulUnmapAtCreation(apiBuffer, buffer, clientHandles, serverHandles);
    }

    // Ensure that the contents on the client and server side are different now as a part of the
    // test.
    mClientBufferContent = kDataGenerator++;
    mServerBufferContent = kDataGenerator++;
    ASSERT_THAT(mClientBufferContent, Ne(mServerBufferContent));

    ExpectSuccessfulMapAsync(apiBuffer, buffer, clientHandles, serverHandles);
    ExpectSuccessfulUnmap(GetParam().mMapMode, apiBuffer, buffer, clientHandles, serverHandles);

    // The client handles are destroyed when the buffer is released.
    ExpectClientHandleDestruction(clientHandles);
    buffer = nullptr;

    // The server handles are destroyed when the release command is flushed.
    ExpectServerHandleDestruction(serverHandles);
    EXPECT_CALL(api, BufferRelease(apiBuffer)).Times(1);
    FlushClient();
}

// Test unsuccessful mapping with error.
TEST_P(WireMemoryTransferServiceBufferMapAsyncTests, Error) {
    wgpu::MapMode mode = GetParam().mMapMode;

    WGPUBuffer apiBuffer;
    wgpu::Buffer buffer;
    MockClientHandles clientHandles;
    MockServerHandles serverHandles;
    std::tie(apiBuffer, buffer, clientHandles, serverHandles) = CreateValidBuffer();

    // If we were mappedAtCreation, successfully handle that initial unmapping now.
    if (GetParam().mMappedAtCreation) {
        ExpectSuccessfulUnmapAtCreation(apiBuffer, buffer, clientHandles, serverHandles);
    }

    buffer.MapAsync(mode, 0, kBufferSize, wgpu::CallbackMode::AllowSpontaneous,
                    mMapAsyncCb.Callback());

    // Make the server respond to the callback with an error.
    EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mode), 0, kBufferSize, _))
        .WillOnce(InvokeWithoutArgs([&] {
            api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Error,
                                           ToOutputStringView("Validation error"));
        }));
    FlushClient();

    // The callback should happen when the server flushes the response.
    EXPECT_CALL(mMapAsyncCb, Call(wgpu::MapAsyncStatus::Error, SizedString("Validation error")))
        .Times(1);
    FlushServer();

    // Unmap the buffer.
    buffer.Unmap();
    EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
    FlushClient();

    // The client handles are destroyed when the buffer is released.
    ExpectClientHandleDestruction(clientHandles);
    buffer = nullptr;

    // The server handles are destroyed when the release command is flushed.
    ExpectServerHandleDestruction(serverHandles);
    EXPECT_CALL(api, BufferRelease(apiBuffer)).Times(1);
    FlushClient();
}

// Test DeserializeDataUpdate (actual data) failure w.r.t MapAsync.
TEST_P(WireMemoryTransferServiceBufferMapAsyncTests, DeserializeDataUpdateFailure) {
    wgpu::MapMode mode = GetParam().mMapMode;

    WGPUBuffer apiBuffer;
    wgpu::Buffer buffer;
    MockClientHandles clientHandles;
    MockServerHandles serverHandles;
    std::tie(apiBuffer, buffer, clientHandles, serverHandles) = CreateValidBuffer();

    // If we were mappedAtCreation, successfully handle that initial unmapping now.
    if (GetParam().mMappedAtCreation) {
        ExpectSuccessfulUnmapAtCreation(apiBuffer, buffer, clientHandles, serverHandles);
    }

    // Set mode independent expectations for the map async call now.
    EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mode), 0, kBufferSize, _))
        .WillOnce(InvokeWithoutArgs([&] {
            api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
                                           kEmptyOutputStringView);
        }));

    switch (mode) {
        case wgpu::MapMode::Read: {
            EXPECT_CALL(mMapAsyncCb, Call(Ne(wgpu::MapAsyncStatus::Success), _)).Times(1);
            EXPECT_CALL(api, BufferGetConstMappedRange(apiBuffer, 0, kBufferSize))
                .WillOnce(Return(&mServerBufferContent));

            buffer.MapAsync(mode, 0, kBufferSize, wgpu::CallbackMode::AllowSpontaneous,
                            mMapAsyncCb.Callback());

            // The server should serialize its buffer when the client flushes.
            ExpectServerSerializeData(serverHandles);
            FlushClient();

            // Mock that the client fails to deserialize into its buffer when the server flushes.
            ExpectClientDeserializeData(false, clientHandles);
            FlushServer(false);
            break;
        }
        case wgpu::MapMode::Write: {
            EXPECT_CALL(mMapAsyncCb, Call(wgpu::MapAsyncStatus::Success, _)).Times(1);
            EXPECT_CALL(api, BufferGetMappedRange(apiBuffer, 0, kBufferSize))
                .WillOnce(Return(&mClientBufferContent));
            auto* clientHandle = std::get<MockClientWriteHandle*>(clientHandles);
            ASSERT_THAT(clientHandle, NotNull());
            EXPECT_CALL(*clientHandle, GetData).WillOnce(Return(&mClientBufferContent));

            buffer.MapAsync(mode, 0, kBufferSize, wgpu::CallbackMode::AllowSpontaneous,
                            mMapAsyncCb.Callback());
            FlushClient();
            FlushServer();

            // The client should serialize its buffer when Unmap is called.
            ExpectClientSerializeData(clientHandles);
            buffer.Unmap();

            // Mock that the server fails to deserialize into its buffer when the client flushes.
            ExpectServerDeserializeData(false, serverHandles);
            FlushClient(false);
            break;
        }
        default:
            DAWN_UNREACHABLE();
    }

    // The client handles are destroyed when the buffer is released.
    ExpectClientHandleDestruction(clientHandles);
    buffer = nullptr;

    // The server handles are destroyed when the release command is flushed.
    ExpectServerHandleDestruction(serverHandles);
    EXPECT_CALL(api, BufferRelease(apiBuffer)).Times(1);
    FlushClient();
}

// Test mapping and then destroying the buffer before unmapping on the client side.
TEST_P(WireMemoryTransferServiceBufferMapAsyncTests, DestroyBeforeUnmap) {
    WGPUBuffer apiBuffer;
    wgpu::Buffer buffer;
    MockClientHandles clientHandles;
    MockServerHandles serverHandles;
    std::tie(apiBuffer, buffer, clientHandles, serverHandles) = CreateValidBuffer();

    // If we were mappedAtCreation, successfully handle that initial unmapping now.
    if (GetParam().mMappedAtCreation) {
        ExpectSuccessfulUnmapAtCreation(apiBuffer, buffer, clientHandles, serverHandles);
    }

    ExpectSuccessfulMapAsync(apiBuffer, buffer, clientHandles, serverHandles);

    // THIS IS THE TEST: destroy the buffer before unmapping and check it destroyed the mapping
    // immediately, both in the client and server side.
    {
        // Destroying the buffer should immediately destroy the client handles.
        ExpectClientHandleDestruction(clientHandles);
        buffer.Destroy();

        // Flushing the client should destroy the server handles.
        ExpectServerHandleDestruction(serverHandles);
        EXPECT_CALL(api, BufferDestroy(apiBuffer)).Times(1);
        FlushClient();

        // The handle(s) are already destroyed so unmap only results in a server unmap call.
        buffer.Unmap();
        EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
        FlushClient();
    }

    // The handle(s) are already destroyed so release only results in a server release call.
    buffer = nullptr;
    EXPECT_CALL(api, BufferRelease(apiBuffer)).Times(1);
    FlushClient();
}

class WireMemoryTransferServiceBufferMappedAtCreationTests
    : public WireMemoryTransferServiceTestBase {};
INSTANTIATE_TEST_SUITE_P(
    ,
    WireMemoryTransferServiceBufferMappedAtCreationTests,
    testing::ValuesIn(
        ParamGenerator<WireMemoryTransferServiceBufferMappedAtCreationTests::ParamType,
                       MapMode,
                       MappedAtCreation>({wgpu::MapMode::Read, wgpu::MapMode::Write}, {true})),
    &TestParamToString<WireMemoryTransferServiceBufferMappedAtCreationTests::ParamType>);

// Test DeserializeDataUpdate (actual data) failure w.r.t for the initial Unmap.
TEST_P(WireMemoryTransferServiceBufferMappedAtCreationTests, DeserializeDataUpdateFailure) {
    WGPUBuffer apiBuffer;
    wgpu::Buffer buffer;
    MockClientHandles clientHandles;
    MockServerHandles serverHandles;
    std::tie(apiBuffer, buffer, clientHandles, serverHandles) = CreateValidBuffer();

    // The client should serialize its buffer when Unmap is called. Additionally, if we are in read
    // mode, the client side WriteHandle used for mappedAtCreation should be destroyed now and it
    // should reset to use the ReadHandle.
    ExpectClientSerializeData(clientHandles);
    if (GetParam().mMapMode == wgpu::MapMode::Read) {
        auto* clientWriteHandle = std::get<MockClientWriteHandle*>(clientHandles);
        ASSERT_THAT(clientWriteHandle, NotNull());
        EXPECT_CALL(*clientWriteHandle, Destroy).Times(1);
        auto* clientReadHandle = std::get<MockClientReadHandle*>(clientHandles);
        ASSERT_THAT(clientReadHandle, NotNull());
        EXPECT_CALL(*clientReadHandle, GetData).WillOnce(Return(&mClientBufferContent));
        clientHandles = std::make_tuple(std::get<MockClientReadHandle*>(clientHandles), nullptr);
    }
    buffer.Unmap();

    // Mock that the server fails to deserialize into its buffer when the client flushes.
    ExpectServerDeserializeData(false, serverHandles);
    FlushClient(false);

    // The client handles are destroyed when the buffer is released.
    ExpectClientHandleDestruction(clientHandles);
    buffer = nullptr;

    // The server handles are destroyed when the release command is flushed.
    ExpectServerHandleDestruction(serverHandles);
    EXPECT_CALL(api, BufferRelease(apiBuffer)).Times(1);
    FlushClient();
}

// Test mapping and then destroying the buffer before unmapping on the client side.
TEST_P(WireMemoryTransferServiceBufferMappedAtCreationTests, DestroyBeforeUnmap) {
    WGPUBuffer apiBuffer;
    wgpu::Buffer buffer;
    MockClientHandles clientHandles;
    MockServerHandles serverHandles;
    std::tie(apiBuffer, buffer, clientHandles, serverHandles) = CreateValidBuffer();

    // THIS IS THE TEST: destroy the buffer before unmapping and check it destroyed the mapping
    // immediately, both in the client and server side.
    {
        // Destroying the buffer should immediately destroy the client handles.
        ExpectClientHandleDestruction(clientHandles);
        buffer.Destroy();

        // Flushing the client should destroy the server handles.
        ExpectServerHandleDestruction(serverHandles);
        EXPECT_CALL(api, BufferDestroy(apiBuffer)).Times(1);
        FlushClient();

        // The handle(s) are already destroyed so unmap only results in a server unmap call.
        buffer.Unmap();
        EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
        FlushClient();
    }

    // The handle(s) are already destroyed so release only results in a server release call.
    buffer = nullptr;
    EXPECT_CALL(api, BufferRelease(apiBuffer)).Times(1);
    FlushClient();
}

}  // anonymous namespace
}  // namespace dawn::wire