src/devices/tools/fidlgen_banjo/tests/cpp/mock-protocolhandle.h

// 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.

// WARNING: THIS FILE IS MACHINE GENERATED. DO NOT EDIT.
// Generated from the banjo.examples.protocolhandle banjo file

#pragma once

#include <tuple>

#include <banjo/examples/protocolhandle/cpp/banjo.h>
#include <lib/mock-function/mock-function.h>

namespace ddk {

// This class mocks a device by providing a synchronous_handle_protocol_t.
// Users can set expectations on how the protocol ops are called and what values they return. After
// the test, use VerifyAndClear to reset the object and verify that all expectations were satisfied.
// See the following example test:
//
// ddk::MockSynchronousHandle synchronous_handle;
//
// /* Set some expectations on the device by calling synchronous_handle.Expect... methods. */
//
// SomeDriver dut(synchronous_handle.GetProto());
//
// EXPECT_OK(dut.SomeMethod());
// ASSERT_NO_FATAL_FAILURES(synchronous_handle.VerifyAndClear());
//
// Note that users must provide the equality operator for struct types, for example:
// bool operator==(const a_struct_type& lhs, const a_struct_type& rhs)

class MockSynchronousHandle : ddk::SynchronousHandleProtocol<MockSynchronousHandle> {
public:
    MockSynchronousHandle() : proto_{&synchronous_handle_protocol_ops_, this} {}

    virtual ~MockSynchronousHandle() {}

    const synchronous_handle_protocol_t* GetProto() const { return &proto_; }

    virtual MockSynchronousHandle& ExpectHandle(const zx::handle& h, zx::handle out_h, zx::handle out_h2) {
        mock_handle_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectProcess(const zx::process& h, zx::process out_h, zx::process out_h2) {
        mock_process_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectThread(const zx::thread& h, zx::thread out_h, zx::thread out_h2) {
        mock_thread_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectVmo(const zx::vmo& h, zx::vmo out_h, zx::vmo out_h2) {
        mock_vmo_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectChannel(const zx::channel& h, zx::channel out_h, zx::channel out_h2) {
        mock_channel_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectEvent(const zx::event& h, zx::event out_h, zx::event out_h2) {
        mock_event_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectPort(const zx::port& h, zx::port out_h, zx::port out_h2) {
        mock_port_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectInterrupt(const zx::interrupt& h, zx::interrupt out_h, zx::interrupt out_h2) {
        mock_interrupt_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectSocket(const zx::socket& h, zx::socket out_h, zx::socket out_h2) {
        mock_socket_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectResource(const zx::resource& h, zx::resource out_h, zx::resource out_h2) {
        mock_resource_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectEventPair(const zx::eventpair& h, zx::eventpair out_h, zx::eventpair out_h2) {
        mock_event_pair_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectJob(const zx::job& h, zx::job out_h, zx::job out_h2) {
        mock_job_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectVmar(const zx::vmar& h, zx::vmar out_h, zx::vmar out_h2) {
        mock_vmar_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectFifo(const zx::fifo& h, zx::fifo out_h, zx::fifo out_h2) {
        mock_fifo_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectGuest(const zx::guest& h, zx::guest out_h, zx::guest out_h2) {
        mock_guest_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectTimer(const zx::timer& h, zx::timer out_h, zx::timer out_h2) {
        mock_timer_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockSynchronousHandle& ExpectProfile(const zx::profile& h, zx::profile out_h, zx::profile out_h2) {
        mock_profile_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    void VerifyAndClear() {
        mock_handle_.VerifyAndClear();
        mock_process_.VerifyAndClear();
        mock_thread_.VerifyAndClear();
        mock_vmo_.VerifyAndClear();
        mock_channel_.VerifyAndClear();
        mock_event_.VerifyAndClear();
        mock_port_.VerifyAndClear();
        mock_interrupt_.VerifyAndClear();
        mock_socket_.VerifyAndClear();
        mock_resource_.VerifyAndClear();
        mock_event_pair_.VerifyAndClear();
        mock_job_.VerifyAndClear();
        mock_vmar_.VerifyAndClear();
        mock_fifo_.VerifyAndClear();
        mock_guest_.VerifyAndClear();
        mock_timer_.VerifyAndClear();
        mock_profile_.VerifyAndClear();
    }

    virtual void SynchronousHandleHandle(zx::handle h, zx::handle* out_h, zx::handle* out_h2) {
        std::tuple<zx::handle, zx::handle> ret = mock_handle_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleProcess(zx::process h, zx::process* out_h, zx::process* out_h2) {
        std::tuple<zx::process, zx::process> ret = mock_process_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleThread(zx::thread h, zx::thread* out_h, zx::thread* out_h2) {
        std::tuple<zx::thread, zx::thread> ret = mock_thread_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleVmo(zx::vmo h, zx::vmo* out_h, zx::vmo* out_h2) {
        std::tuple<zx::vmo, zx::vmo> ret = mock_vmo_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleChannel(zx::channel h, zx::channel* out_h, zx::channel* out_h2) {
        std::tuple<zx::channel, zx::channel> ret = mock_channel_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleEvent(zx::event h, zx::event* out_h, zx::event* out_h2) {
        std::tuple<zx::event, zx::event> ret = mock_event_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandlePort(zx::port h, zx::port* out_h, zx::port* out_h2) {
        std::tuple<zx::port, zx::port> ret = mock_port_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleInterrupt(zx::interrupt h, zx::interrupt* out_h, zx::interrupt* out_h2) {
        std::tuple<zx::interrupt, zx::interrupt> ret = mock_interrupt_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleSocket(zx::socket h, zx::socket* out_h, zx::socket* out_h2) {
        std::tuple<zx::socket, zx::socket> ret = mock_socket_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleResource(zx::resource h, zx::resource* out_h, zx::resource* out_h2) {
        std::tuple<zx::resource, zx::resource> ret = mock_resource_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleEventPair(zx::eventpair h, zx::eventpair* out_h, zx::eventpair* out_h2) {
        std::tuple<zx::eventpair, zx::eventpair> ret = mock_event_pair_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleJob(zx::job h, zx::job* out_h, zx::job* out_h2) {
        std::tuple<zx::job, zx::job> ret = mock_job_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleVmar(zx::vmar h, zx::vmar* out_h, zx::vmar* out_h2) {
        std::tuple<zx::vmar, zx::vmar> ret = mock_vmar_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleFifo(zx::fifo h, zx::fifo* out_h, zx::fifo* out_h2) {
        std::tuple<zx::fifo, zx::fifo> ret = mock_fifo_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleGuest(zx::guest h, zx::guest* out_h, zx::guest* out_h2) {
        std::tuple<zx::guest, zx::guest> ret = mock_guest_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleTimer(zx::timer h, zx::timer* out_h, zx::timer* out_h2) {
        std::tuple<zx::timer, zx::timer> ret = mock_timer_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    virtual void SynchronousHandleProfile(zx::profile h, zx::profile* out_h, zx::profile* out_h2) {
        std::tuple<zx::profile, zx::profile> ret = mock_profile_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    mock_function::MockFunction<std::tuple<zx::handle, zx::handle>, zx::handle>& mock_handle() { return mock_handle_; }
    mock_function::MockFunction<std::tuple<zx::process, zx::process>, zx::process>& mock_process() { return mock_process_; }
    mock_function::MockFunction<std::tuple<zx::thread, zx::thread>, zx::thread>& mock_thread() { return mock_thread_; }
    mock_function::MockFunction<std::tuple<zx::vmo, zx::vmo>, zx::vmo>& mock_vmo() { return mock_vmo_; }
    mock_function::MockFunction<std::tuple<zx::channel, zx::channel>, zx::channel>& mock_channel() { return mock_channel_; }
    mock_function::MockFunction<std::tuple<zx::event, zx::event>, zx::event>& mock_event() { return mock_event_; }
    mock_function::MockFunction<std::tuple<zx::port, zx::port>, zx::port>& mock_port() { return mock_port_; }
    mock_function::MockFunction<std::tuple<zx::interrupt, zx::interrupt>, zx::interrupt>& mock_interrupt() { return mock_interrupt_; }
    mock_function::MockFunction<std::tuple<zx::socket, zx::socket>, zx::socket>& mock_socket() { return mock_socket_; }
    mock_function::MockFunction<std::tuple<zx::resource, zx::resource>, zx::resource>& mock_resource() { return mock_resource_; }
    mock_function::MockFunction<std::tuple<zx::eventpair, zx::eventpair>, zx::eventpair>& mock_event_pair() { return mock_event_pair_; }
    mock_function::MockFunction<std::tuple<zx::job, zx::job>, zx::job>& mock_job() { return mock_job_; }
    mock_function::MockFunction<std::tuple<zx::vmar, zx::vmar>, zx::vmar>& mock_vmar() { return mock_vmar_; }
    mock_function::MockFunction<std::tuple<zx::fifo, zx::fifo>, zx::fifo>& mock_fifo() { return mock_fifo_; }
    mock_function::MockFunction<std::tuple<zx::guest, zx::guest>, zx::guest>& mock_guest() { return mock_guest_; }
    mock_function::MockFunction<std::tuple<zx::timer, zx::timer>, zx::timer>& mock_timer() { return mock_timer_; }
    mock_function::MockFunction<std::tuple<zx::profile, zx::profile>, zx::profile>& mock_profile() { return mock_profile_; }

protected:
    mock_function::MockFunction<std::tuple<zx::handle, zx::handle>, zx::handle> mock_handle_;
    mock_function::MockFunction<std::tuple<zx::process, zx::process>, zx::process> mock_process_;
    mock_function::MockFunction<std::tuple<zx::thread, zx::thread>, zx::thread> mock_thread_;
    mock_function::MockFunction<std::tuple<zx::vmo, zx::vmo>, zx::vmo> mock_vmo_;
    mock_function::MockFunction<std::tuple<zx::channel, zx::channel>, zx::channel> mock_channel_;
    mock_function::MockFunction<std::tuple<zx::event, zx::event>, zx::event> mock_event_;
    mock_function::MockFunction<std::tuple<zx::port, zx::port>, zx::port> mock_port_;
    mock_function::MockFunction<std::tuple<zx::interrupt, zx::interrupt>, zx::interrupt> mock_interrupt_;
    mock_function::MockFunction<std::tuple<zx::socket, zx::socket>, zx::socket> mock_socket_;
    mock_function::MockFunction<std::tuple<zx::resource, zx::resource>, zx::resource> mock_resource_;
    mock_function::MockFunction<std::tuple<zx::eventpair, zx::eventpair>, zx::eventpair> mock_event_pair_;
    mock_function::MockFunction<std::tuple<zx::job, zx::job>, zx::job> mock_job_;
    mock_function::MockFunction<std::tuple<zx::vmar, zx::vmar>, zx::vmar> mock_vmar_;
    mock_function::MockFunction<std::tuple<zx::fifo, zx::fifo>, zx::fifo> mock_fifo_;
    mock_function::MockFunction<std::tuple<zx::guest, zx::guest>, zx::guest> mock_guest_;
    mock_function::MockFunction<std::tuple<zx::timer, zx::timer>, zx::timer> mock_timer_;
    mock_function::MockFunction<std::tuple<zx::profile, zx::profile>, zx::profile> mock_profile_;

private:
    const synchronous_handle_protocol_t proto_;
};

// This class mocks a device by providing a async_handle_protocol_t.
// Users can set expectations on how the protocol ops are called and what values they return. After
// the test, use VerifyAndClear to reset the object and verify that all expectations were satisfied.
// See the following example test:
//
// ddk::MockAsyncHandle async_handle;
//
// /* Set some expectations on the device by calling async_handle.Expect... methods. */
//
// SomeDriver dut(async_handle.GetProto());
//
// EXPECT_OK(dut.SomeMethod());
// ASSERT_NO_FATAL_FAILURES(async_handle.VerifyAndClear());
//
// Note that users must provide the equality operator for struct types, for example:
// bool operator==(const a_struct_type& lhs, const a_struct_type& rhs)

class MockAsyncHandle : ddk::AsyncHandleProtocol<MockAsyncHandle> {
public:
    MockAsyncHandle() : proto_{&async_handle_protocol_ops_, this} {}

    virtual ~MockAsyncHandle() {}

    const async_handle_protocol_t* GetProto() const { return &proto_; }

    virtual MockAsyncHandle& ExpectHandle(const zx::handle& h, zx::handle out_h, zx::handle out_h2) {
        mock_handle_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectProcess(const zx::process& h, zx::process out_h, zx::process out_h2) {
        mock_process_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectThread(const zx::thread& h, zx::thread out_h, zx::thread out_h2) {
        mock_thread_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectVmo(const zx::vmo& h, zx::vmo out_h, zx::vmo out_h2) {
        mock_vmo_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectChannel(const zx::channel& h, zx::channel out_h, zx::channel out_h2) {
        mock_channel_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectEvent(const zx::event& h, zx::event out_h, zx::event out_h2) {
        mock_event_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectPort(const zx::port& h, zx::port out_h, zx::port out_h2) {
        mock_port_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectInterrupt(const zx::interrupt& h, zx::interrupt out_h, zx::interrupt out_h2) {
        mock_interrupt_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectSocket(const zx::socket& h, zx::socket out_h, zx::socket out_h2) {
        mock_socket_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectResource(const zx::resource& h, zx::resource out_h, zx::resource out_h2) {
        mock_resource_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectEventPair(const zx::eventpair& h, zx::eventpair out_h, zx::eventpair out_h2) {
        mock_event_pair_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectJob(const zx::job& h, zx::job out_h, zx::job out_h2) {
        mock_job_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectVmar(const zx::vmar& h, zx::vmar out_h, zx::vmar out_h2) {
        mock_vmar_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectFifo(const zx::fifo& h, zx::fifo out_h, zx::fifo out_h2) {
        mock_fifo_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectGuest(const zx::guest& h, zx::guest out_h, zx::guest out_h2) {
        mock_guest_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectTimer(const zx::timer& h, zx::timer out_h, zx::timer out_h2) {
        mock_timer_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    virtual MockAsyncHandle& ExpectProfile(const zx::profile& h, zx::profile out_h, zx::profile out_h2) {
        mock_profile_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    void VerifyAndClear() {
        mock_handle_.VerifyAndClear();
        mock_process_.VerifyAndClear();
        mock_thread_.VerifyAndClear();
        mock_vmo_.VerifyAndClear();
        mock_channel_.VerifyAndClear();
        mock_event_.VerifyAndClear();
        mock_port_.VerifyAndClear();
        mock_interrupt_.VerifyAndClear();
        mock_socket_.VerifyAndClear();
        mock_resource_.VerifyAndClear();
        mock_event_pair_.VerifyAndClear();
        mock_job_.VerifyAndClear();
        mock_vmar_.VerifyAndClear();
        mock_fifo_.VerifyAndClear();
        mock_guest_.VerifyAndClear();
        mock_timer_.VerifyAndClear();
        mock_profile_.VerifyAndClear();
    }

    virtual void AsyncHandleHandle(zx::handle h, async_handle_handle_callback callback, void* cookie) {
        std::tuple<zx::handle, zx::handle> ret = mock_handle_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleProcess(zx::process h, async_handle_process_callback callback, void* cookie) {
        std::tuple<zx::process, zx::process> ret = mock_process_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleThread(zx::thread h, async_handle_thread_callback callback, void* cookie) {
        std::tuple<zx::thread, zx::thread> ret = mock_thread_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleVmo(zx::vmo h, async_handle_vmo_callback callback, void* cookie) {
        std::tuple<zx::vmo, zx::vmo> ret = mock_vmo_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleChannel(zx::channel h, async_handle_channel_callback callback, void* cookie) {
        std::tuple<zx::channel, zx::channel> ret = mock_channel_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleEvent(zx::event h, async_handle_event_callback callback, void* cookie) {
        std::tuple<zx::event, zx::event> ret = mock_event_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandlePort(zx::port h, async_handle_port_callback callback, void* cookie) {
        std::tuple<zx::port, zx::port> ret = mock_port_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleInterrupt(zx::interrupt h, async_handle_interrupt_callback callback, void* cookie) {
        std::tuple<zx::interrupt, zx::interrupt> ret = mock_interrupt_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleSocket(zx::socket h, async_handle_socket_callback callback, void* cookie) {
        std::tuple<zx::socket, zx::socket> ret = mock_socket_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleResource(zx::resource h, async_handle_resource_callback callback, void* cookie) {
        std::tuple<zx::resource, zx::resource> ret = mock_resource_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleEventPair(zx::eventpair h, async_handle_event_pair_callback callback, void* cookie) {
        std::tuple<zx::eventpair, zx::eventpair> ret = mock_event_pair_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleJob(zx::job h, async_handle_job_callback callback, void* cookie) {
        std::tuple<zx::job, zx::job> ret = mock_job_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleVmar(zx::vmar h, async_handle_vmar_callback callback, void* cookie) {
        std::tuple<zx::vmar, zx::vmar> ret = mock_vmar_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleFifo(zx::fifo h, async_handle_fifo_callback callback, void* cookie) {
        std::tuple<zx::fifo, zx::fifo> ret = mock_fifo_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleGuest(zx::guest h, async_handle_guest_callback callback, void* cookie) {
        std::tuple<zx::guest, zx::guest> ret = mock_guest_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleTimer(zx::timer h, async_handle_timer_callback callback, void* cookie) {
        std::tuple<zx::timer, zx::timer> ret = mock_timer_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    virtual void AsyncHandleProfile(zx::profile h, async_handle_profile_callback callback, void* cookie) {
        std::tuple<zx::profile, zx::profile> ret = mock_profile_.Call(std::move(h));
        callback(cookie, std::move(std::get<0>(ret)), std::move(std::get<1>(ret)));
    }

    mock_function::MockFunction<std::tuple<zx::handle, zx::handle>, zx::handle>& mock_handle() { return mock_handle_; }
    mock_function::MockFunction<std::tuple<zx::process, zx::process>, zx::process>& mock_process() { return mock_process_; }
    mock_function::MockFunction<std::tuple<zx::thread, zx::thread>, zx::thread>& mock_thread() { return mock_thread_; }
    mock_function::MockFunction<std::tuple<zx::vmo, zx::vmo>, zx::vmo>& mock_vmo() { return mock_vmo_; }
    mock_function::MockFunction<std::tuple<zx::channel, zx::channel>, zx::channel>& mock_channel() { return mock_channel_; }
    mock_function::MockFunction<std::tuple<zx::event, zx::event>, zx::event>& mock_event() { return mock_event_; }
    mock_function::MockFunction<std::tuple<zx::port, zx::port>, zx::port>& mock_port() { return mock_port_; }
    mock_function::MockFunction<std::tuple<zx::interrupt, zx::interrupt>, zx::interrupt>& mock_interrupt() { return mock_interrupt_; }
    mock_function::MockFunction<std::tuple<zx::socket, zx::socket>, zx::socket>& mock_socket() { return mock_socket_; }
    mock_function::MockFunction<std::tuple<zx::resource, zx::resource>, zx::resource>& mock_resource() { return mock_resource_; }
    mock_function::MockFunction<std::tuple<zx::eventpair, zx::eventpair>, zx::eventpair>& mock_event_pair() { return mock_event_pair_; }
    mock_function::MockFunction<std::tuple<zx::job, zx::job>, zx::job>& mock_job() { return mock_job_; }
    mock_function::MockFunction<std::tuple<zx::vmar, zx::vmar>, zx::vmar>& mock_vmar() { return mock_vmar_; }
    mock_function::MockFunction<std::tuple<zx::fifo, zx::fifo>, zx::fifo>& mock_fifo() { return mock_fifo_; }
    mock_function::MockFunction<std::tuple<zx::guest, zx::guest>, zx::guest>& mock_guest() { return mock_guest_; }
    mock_function::MockFunction<std::tuple<zx::timer, zx::timer>, zx::timer>& mock_timer() { return mock_timer_; }
    mock_function::MockFunction<std::tuple<zx::profile, zx::profile>, zx::profile>& mock_profile() { return mock_profile_; }

protected:
    mock_function::MockFunction<std::tuple<zx::handle, zx::handle>, zx::handle> mock_handle_;
    mock_function::MockFunction<std::tuple<zx::process, zx::process>, zx::process> mock_process_;
    mock_function::MockFunction<std::tuple<zx::thread, zx::thread>, zx::thread> mock_thread_;
    mock_function::MockFunction<std::tuple<zx::vmo, zx::vmo>, zx::vmo> mock_vmo_;
    mock_function::MockFunction<std::tuple<zx::channel, zx::channel>, zx::channel> mock_channel_;
    mock_function::MockFunction<std::tuple<zx::event, zx::event>, zx::event> mock_event_;
    mock_function::MockFunction<std::tuple<zx::port, zx::port>, zx::port> mock_port_;
    mock_function::MockFunction<std::tuple<zx::interrupt, zx::interrupt>, zx::interrupt> mock_interrupt_;
    mock_function::MockFunction<std::tuple<zx::socket, zx::socket>, zx::socket> mock_socket_;
    mock_function::MockFunction<std::tuple<zx::resource, zx::resource>, zx::resource> mock_resource_;
    mock_function::MockFunction<std::tuple<zx::eventpair, zx::eventpair>, zx::eventpair> mock_event_pair_;
    mock_function::MockFunction<std::tuple<zx::job, zx::job>, zx::job> mock_job_;
    mock_function::MockFunction<std::tuple<zx::vmar, zx::vmar>, zx::vmar> mock_vmar_;
    mock_function::MockFunction<std::tuple<zx::fifo, zx::fifo>, zx::fifo> mock_fifo_;
    mock_function::MockFunction<std::tuple<zx::guest, zx::guest>, zx::guest> mock_guest_;
    mock_function::MockFunction<std::tuple<zx::timer, zx::timer>, zx::timer> mock_timer_;
    mock_function::MockFunction<std::tuple<zx::profile, zx::profile>, zx::profile> mock_profile_;

private:
    const async_handle_protocol_t proto_;
};

// This class mocks a device by providing a another_synchronous_handle_protocol_t.
// Users can set expectations on how the protocol ops are called and what values they return. After
// the test, use VerifyAndClear to reset the object and verify that all expectations were satisfied.
// See the following example test:
//
// ddk::MockAnotherSynchronousHandle another_synchronous_handle;
//
// /* Set some expectations on the device by calling another_synchronous_handle.Expect... methods. */
//
// SomeDriver dut(another_synchronous_handle.GetProto());
//
// EXPECT_OK(dut.SomeMethod());
// ASSERT_NO_FATAL_FAILURES(another_synchronous_handle.VerifyAndClear());
//
// Note that users must provide the equality operator for struct types, for example:
// bool operator==(const a_struct_type& lhs, const a_struct_type& rhs)

class MockAnotherSynchronousHandle : ddk::AnotherSynchronousHandleProtocol<MockAnotherSynchronousHandle> {
public:
    MockAnotherSynchronousHandle() : proto_{&another_synchronous_handle_protocol_ops_, this} {}

    virtual ~MockAnotherSynchronousHandle() {}

    const another_synchronous_handle_protocol_t* GetProto() const { return &proto_; }

    virtual MockAnotherSynchronousHandle& ExpectHandle(const zx::handle& h, zx::handle out_h, zx::handle out_h2) {
        mock_handle_.ExpectCall({std::move(out_h), std::move(out_h2)}, h.get());
        return *this;
    }

    void VerifyAndClear() {
        mock_handle_.VerifyAndClear();
    }

    virtual void AnotherSynchronousHandleHandle(zx::handle h, zx::handle* out_h, zx::handle* out_h2) {
        std::tuple<zx::handle, zx::handle> ret = mock_handle_.Call(std::move(h));
        *out_h = std::move(std::get<0>(ret));
        *out_h2 = std::move(std::get<1>(ret));
    }

    mock_function::MockFunction<std::tuple<zx::handle, zx::handle>, zx::handle>& mock_handle() { return mock_handle_; }

protected:
    mock_function::MockFunction<std::tuple<zx::handle, zx::handle>, zx::handle> mock_handle_;

private:
    const another_synchronous_handle_protocol_t proto_;
};

} // namespace ddk