zircon/system/ulib/async/test/wait_tests.cc - fuchsia - Git at Google

 // Copyright 2017 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <lib/async-testing/dispatcher_stub.h>
 #include <lib/async/cpp/wait.h>
 #include <lib/fit/defer.h>

 #include <zxtest/zxtest.h>

 namespace {

 const zx_handle_t dummy_handle = static_cast<zx_handle_t>(1);
 const zx_signals_t dummy_trigger = ZX_USER_SIGNAL_0;
 const uint32_t dummy_options = 0x55;
 const zx_packet_signal_t dummy_signal{.trigger = dummy_trigger,
                                       .observed = ZX_USER_SIGNAL_0 | ZX_USER_SIGNAL_1,
                                       .count = 0u,
                                       .timestamp = 0u,
                                       .reserved1 = 0u};

 class MockDispatcher : public async::DispatcherStub {
  public:
   enum class Op {
     NONE,
     BEGIN_WAIT,
     CANCEL_WAIT,
   };

   // DispatcherStub

   zx_status_t BeginWait(async_wait_t* wait) override {
     ZX_ASSERT(wait->object == dummy_handle);
     // Using an invalid handle would cause a policy exception.
     ZX_ASSERT_MSG(wait->object != last_dummy_handle_deleted,
                   "BeginWait() called with already-deleted object");
     last_op = Op::BEGIN_WAIT;
     last_wait = wait;
     return next_status;
   }

   zx_status_t CancelWait(async_wait_t* wait) override {
     ZX_ASSERT(wait->object == dummy_handle);
     // Using an invalid handle would cause a policy exception.
     ZX_ASSERT_MSG(wait->object != last_dummy_handle_deleted,
                   "CancelWait() called with already-deleted object");
     last_op = Op::CANCEL_WAIT;
     last_wait = wait;
     return next_status;
   }

   // Test utilities
   Op last_op = Op::NONE;
   async_wait_t* last_wait = nullptr;
   zx_handle_t last_dummy_handle_deleted = ZX_HANDLE_INVALID;
   zx_status_t next_status = ZX_OK;
 };

 class Harness {
  public:
   explicit Harness(MockDispatcher* mock_dispatcher) : mock_dispatcher_(mock_dispatcher) { Reset(); }
   virtual ~Harness() = default;

   void Reset() {
     handler_ran = false;
     handler_deleted = false;
     last_wait = nullptr;
     last_status = ZX_ERR_INTERNAL;
     last_signal = nullptr;
   }

   void Handler(async_dispatcher_t* dispatcher, async::WaitBase* wait, zx_status_t status,
                const zx_packet_signal_t* signal) {
     handler_ran = true;
     last_wait = wait;
     last_status = status;
     last_signal = signal;
   }

   virtual async::WaitBase& wait() = 0;
   virtual bool wait_has_handler() = 0;
   virtual bool wait_retains_handler() = 0;

   virtual zx_status_t BeginWait(async_dispatcher_t* dispatcher) = 0;

   // Unaffected by Reset().
   MockDispatcher* mock_dispatcher_ = nullptr;

   // Reset() during construction, and when Reset() is called separately.
   bool handler_ran;
   bool handler_deleted;
   async::WaitBase* last_wait;
   zx_status_t last_status;
   const zx_packet_signal_t* last_signal;
 };

 class LambdaHarness : public Harness {
  public:
   // The on_handler_destruct simulates the dummy_handle/object being deleted as soon as the
   // handler is deleted (which is the soonest it should ever be deleted), and notes that the
   // handler has actually been deleted (not just moved somewhere else).
   LambdaHarness(MockDispatcher* mock_dispatcher, zx_handle_t object = ZX_HANDLE_INVALID,
                 zx_signals_t trigger = ZX_SIGNAL_NONE, uint32_t options = 0)
       : Harness(mock_dispatcher),
         wait_{object, trigger, options,
               [this, on_handler_destruct = fit::defer([this] {
                        mock_dispatcher_->last_dummy_handle_deleted = dummy_handle;
                        handler_deleted = true;
                      })](async_dispatcher_t* dispatcher, async::Wait* wait, zx_status_t status,
                          const zx_packet_signal_t* signal) {
                 Handler(dispatcher, wait, status, signal);
               }} {}

   async::WaitBase& wait() override { return wait_; }
   bool wait_has_handler() override { return wait_.has_handler(); }
   bool wait_retains_handler() override { return true; }

   zx_status_t BeginWait(async_dispatcher_t* dispatcher) override { return wait_.Begin(dispatcher); }

  private:
   async::Wait wait_;
 };

 class LambdaOnceHarness : public Harness {
  public:
   LambdaOnceHarness(MockDispatcher* mock_dispatcher, zx_handle_t object = ZX_HANDLE_INVALID,
                     zx_signals_t trigger = ZX_SIGNAL_NONE, uint32_t options = 0)
       : Harness(mock_dispatcher), wait_{object, trigger, options} {}

   async::WaitBase& wait() override { return wait_; }
   bool wait_has_handler() override { return !handler_ran; }
   bool wait_retains_handler() override { return false; }

   zx_status_t BeginWait(async_dispatcher_t* dispatcher) override {
     // The on_handler_destruct simulates the dummy_handle/object being deleted as soon as the
     // handler is deleted (which is the soonest it should ever be deleted), and notes that the
     // handler has actually been deleted (not just moved somewhere else).
     //
     // We only simulate this if there's not already a BeginWait() in progress.
     //
     // While it's true that if a client calls async::WaitOnce::Begin() on a WaitOnce instance that
     // already has a wait in progress, passing in a handler which when deleted will delete the
     // same object as the handler for the wait that's already in progress, that's a client bug.
     // If a client really needed to attempt a second BeginWait() (it really doesn't need to), then
     // it could co-own instead of double-own the object in each of two handlers, where the second
     // handler's immediate deletion during failed BeginWait() would just de-ref, not actually
     // delete.
     auto on_handler_destruct = fit::defer([this, was_fresh_wait = !wait_.is_pending()] {
       if (was_fresh_wait) {
         mock_dispatcher_->last_dummy_handle_deleted = dummy_handle;
         handler_deleted = true;
       }
     });
     return wait_.Begin(dispatcher, [this, on_handler_destruct = std::move(on_handler_destruct)](
                                        async_dispatcher_t* dispatcher, async::WaitOnce* wait,
                                        zx_status_t status, const zx_packet_signal_t* signal) {
       Handler(dispatcher, wait, status, signal);
     });
   }

  private:
   async::WaitOnce wait_;
 };

 class MethodHarness : public Harness {
  public:
   MethodHarness(MockDispatcher* mock_dispatcher, zx_handle_t object = ZX_HANDLE_INVALID,
                 zx_signals_t trigger = ZX_SIGNAL_NONE, uint32_t options = 0)
       : Harness(mock_dispatcher), wait_{this, object, trigger, options} {}

   async::WaitBase& wait() override { return wait_; }
   bool wait_has_handler() override { return true; }
   bool wait_retains_handler() override { return true; }

   zx_status_t BeginWait(async_dispatcher_t* dispatcher) override { return wait_.Begin(dispatcher); }

  private:
   async::WaitMethod<Harness, &Harness::Handler> wait_;
 };

 TEST(WaitTests, wait_set_handler_test) {
   {
     async::Wait wait;
     EXPECT_FALSE(wait.has_handler());
     EXPECT_FALSE(wait.is_pending());

     wait.set_handler([](async_dispatcher_t* dispatcher, async::Wait* wait, zx_status_t status,
                         const zx_packet_signal_t* signal) {});
     EXPECT_TRUE(wait.has_handler());
   }

   {
     async::Wait wait(ZX_HANDLE_INVALID, ZX_SIGNAL_NONE, 0,
                      [](async_dispatcher_t* dispatcher, async::Wait* wait, zx_status_t status,
                         const zx_packet_signal_t* signal) {});
     EXPECT_TRUE(wait.has_handler());
     EXPECT_FALSE(wait.is_pending());
   }
 }

 template <typename Harness>
 void wait_properties_test() {
   MockDispatcher dispatcher;
   Harness harness(&dispatcher);

   EXPECT_EQ(ZX_HANDLE_INVALID, harness.wait().object());
   harness.wait().set_object(dummy_handle);
   EXPECT_EQ(dummy_handle, harness.wait().object());

   EXPECT_EQ(ZX_SIGNAL_NONE, harness.wait().trigger());
   harness.wait().set_trigger(dummy_trigger);
   EXPECT_EQ(dummy_trigger, harness.wait().trigger());

   EXPECT_EQ(0, harness.wait().options());
   harness.wait().set_options(dummy_options);
   EXPECT_EQ(dummy_options, harness.wait().options());
 }

 template <typename Harness>
 void wait_begin_test() {
   MockDispatcher dispatcher;

   {
     Harness harness(&dispatcher, dummy_handle, dummy_trigger, dummy_options);
     EXPECT_FALSE(harness.wait().is_pending());

     dispatcher.next_status = ZX_OK;
     EXPECT_EQ(ZX_OK, harness.BeginWait(&dispatcher));
     EXPECT_TRUE(harness.wait().is_pending());
     EXPECT_EQ(MockDispatcher::Op::BEGIN_WAIT, dispatcher.last_op);
     EXPECT_EQ(dummy_handle, dispatcher.last_wait->object);
     EXPECT_EQ(dummy_trigger, dispatcher.last_wait->trigger);
     EXPECT_EQ(dummy_options, dispatcher.last_wait->options);
     EXPECT_FALSE(harness.handler_ran);

     harness.Reset();
     dispatcher.last_op = MockDispatcher::Op::NONE;
     EXPECT_EQ(ZX_ERR_ALREADY_EXISTS, harness.BeginWait(&dispatcher));
     EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
     EXPECT_FALSE(harness.handler_ran);
   }
   EXPECT_EQ(MockDispatcher::Op::CANCEL_WAIT, dispatcher.last_op);

   // Pretend like we're using a new handle and happen to get dummy_handle value
   // again.
   dispatcher.last_dummy_handle_deleted = ZX_HANDLE_INVALID;

   {
     Harness harness(&dispatcher, dummy_handle, dummy_trigger, dummy_options);
     EXPECT_FALSE(harness.wait().is_pending());

     dispatcher.next_status = ZX_ERR_BAD_STATE;
     EXPECT_EQ(ZX_ERR_BAD_STATE, harness.BeginWait(&dispatcher));
     EXPECT_EQ(MockDispatcher::Op::BEGIN_WAIT, dispatcher.last_op);
     EXPECT_FALSE(harness.wait().is_pending());
     EXPECT_FALSE(harness.handler_ran);
   }
   EXPECT_EQ(MockDispatcher::Op::BEGIN_WAIT, dispatcher.last_op);
 }

 template <typename Harness>
 void wait_cancel_test() {
   MockDispatcher dispatcher;

   {
     Harness harness(&dispatcher, dummy_handle, dummy_trigger, dummy_options);
     EXPECT_FALSE(harness.wait().is_pending());

     EXPECT_EQ(ZX_ERR_NOT_FOUND, harness.wait().Cancel());
     EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
     EXPECT_FALSE(harness.wait().is_pending());

     EXPECT_EQ(ZX_OK, harness.BeginWait(&dispatcher));
     EXPECT_EQ(MockDispatcher::Op::BEGIN_WAIT, dispatcher.last_op);
     EXPECT_TRUE(harness.wait().is_pending());

     EXPECT_EQ(ZX_OK, harness.wait().Cancel());
     EXPECT_EQ(MockDispatcher::Op::CANCEL_WAIT, dispatcher.last_op);
     EXPECT_FALSE(harness.wait().is_pending());

     dispatcher.last_op = MockDispatcher::Op::NONE;
     EXPECT_EQ(ZX_ERR_NOT_FOUND, harness.wait().Cancel());
     EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
     EXPECT_FALSE(harness.wait().is_pending());
   }
   EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
 }

 template <typename Harness>
 void wait_run_handler_test() {
   MockDispatcher dispatcher;

   {
     Harness harness(&dispatcher, dummy_handle, dummy_trigger, dummy_options);
     EXPECT_FALSE(harness.wait().is_pending());

     EXPECT_EQ(ZX_OK, harness.BeginWait(&dispatcher));
     EXPECT_EQ(MockDispatcher::Op::BEGIN_WAIT, dispatcher.last_op);
     EXPECT_TRUE(harness.wait().is_pending());

     harness.Reset();
     dispatcher.last_wait->handler(&dispatcher, dispatcher.last_wait, ZX_OK, &dummy_signal);
     EXPECT_TRUE(harness.handler_ran);
     EXPECT_EQ(&harness.wait(), harness.last_wait);
     EXPECT_EQ(ZX_OK, harness.last_status);
     EXPECT_EQ(&dummy_signal, harness.last_signal);
     EXPECT_FALSE(harness.wait().is_pending());

     dispatcher.last_op = MockDispatcher::Op::NONE;
     EXPECT_EQ(ZX_ERR_NOT_FOUND, harness.wait().Cancel());
     EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
     EXPECT_FALSE(harness.wait().is_pending());

     EXPECT_EQ(harness.wait_retains_handler(), harness.wait_has_handler());
     EXPECT_EQ(!harness.wait_retains_handler(), harness.handler_deleted);
   }
   EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
 }

 TEST(WaitTests, unsupported_begin_wait_test) {
   async::DispatcherStub dispatcher;
   async_wait_t wait{};
   EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, async_begin_wait(&dispatcher, &wait), "valid args");
 }

 TEST(WaitTests, unsupported_cancel_wait_test) {
   async::DispatcherStub dispatcher;
   async_wait_t wait{};
   EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, async_cancel_wait(&dispatcher, &wait), "valid args");
 }

 }  // namespace

 TEST(WaitTests, wait_properties_test_LambdaHarness) { wait_properties_test<LambdaHarness>(); }

 TEST(WaitTests, wait_properties_test_LambdaOnceHarness) {
   wait_properties_test<LambdaOnceHarness>();
 }

 TEST(WaitTests, wait_properties_test_MethodHarness) { wait_properties_test<MethodHarness>(); }

 TEST(WaitTests, wait_begin_test_LambdaHarness) { wait_begin_test<LambdaHarness>(); }

 TEST(WaitTests, wait_begin_test_LambdaOnceHarness) { wait_begin_test<LambdaOnceHarness>(); }

 TEST(WaitTests, wait_begin_test_MethodHarness) { wait_begin_test<MethodHarness>(); }

 TEST(WaitTests, wait_cancel_test_LambdaHarness) { wait_cancel_test<LambdaHarness>(); }

 TEST(WaitTests, wait_cancel_test_LambdaOnceHarness) { wait_cancel_test<LambdaOnceHarness>(); }

 TEST(WaitTests, wait_cancel_test_MethodHarness) { wait_cancel_test<MethodHarness>(); }

 TEST(WaitTests, wait_run_handler_test_LambdaHarness) { wait_run_handler_test<LambdaHarness>(); }

 TEST(WaitTests, wait_run_handler_test_LambdaOnceHarness) {
   wait_run_handler_test<LambdaOnceHarness>();
 }

 TEST(WaitTests, wait_run_handler_test_MethodHarness) { wait_run_handler_test<MethodHarness>(); }
	// Copyright 2017 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <lib/async-testing/dispatcher_stub.h>
	#include <lib/async/cpp/wait.h>
	#include <lib/fit/defer.h>

	#include <zxtest/zxtest.h>

	namespace {

	const zx_handle_t dummy_handle = static_cast<zx_handle_t>(1);
	const zx_signals_t dummy_trigger = ZX_USER_SIGNAL_0;
	const uint32_t dummy_options = 0x55;
	const zx_packet_signal_t dummy_signal{.trigger = dummy_trigger,
	.observed = ZX_USER_SIGNAL_0 \| ZX_USER_SIGNAL_1,
	.count = 0u,
	.timestamp = 0u,
	.reserved1 = 0u};

	class MockDispatcher : public async::DispatcherStub {
	public:
	enum class Op {
	NONE,
	BEGIN_WAIT,
	CANCEL_WAIT,
	};

	// DispatcherStub

	zx_status_t BeginWait(async_wait_t* wait) override {
	ZX_ASSERT(wait->object == dummy_handle);
	// Using an invalid handle would cause a policy exception.
	ZX_ASSERT_MSG(wait->object != last_dummy_handle_deleted,
	"BeginWait() called with already-deleted object");
	last_op = Op::BEGIN_WAIT;
	last_wait = wait;
	return next_status;
	}

	zx_status_t CancelWait(async_wait_t* wait) override {
	ZX_ASSERT(wait->object == dummy_handle);
	// Using an invalid handle would cause a policy exception.
	ZX_ASSERT_MSG(wait->object != last_dummy_handle_deleted,
	"CancelWait() called with already-deleted object");
	last_op = Op::CANCEL_WAIT;
	last_wait = wait;
	return next_status;
	}

	// Test utilities
	Op last_op = Op::NONE;
	async_wait_t* last_wait = nullptr;
	zx_handle_t last_dummy_handle_deleted = ZX_HANDLE_INVALID;
	zx_status_t next_status = ZX_OK;
	};

	class Harness {
	public:
	explicit Harness(MockDispatcher* mock_dispatcher) : mock_dispatcher_(mock_dispatcher) { Reset(); }
	virtual ~Harness() = default;

	void Reset() {
	handler_ran = false;
	handler_deleted = false;
	last_wait = nullptr;
	last_status = ZX_ERR_INTERNAL;
	last_signal = nullptr;
	}

	void Handler(async_dispatcher_t* dispatcher, async::WaitBase* wait, zx_status_t status,
	const zx_packet_signal_t* signal) {
	handler_ran = true;
	last_wait = wait;
	last_status = status;
	last_signal = signal;
	}

	virtual async::WaitBase& wait() = 0;
	virtual bool wait_has_handler() = 0;
	virtual bool wait_retains_handler() = 0;

	virtual zx_status_t BeginWait(async_dispatcher_t* dispatcher) = 0;

	// Unaffected by Reset().
	MockDispatcher* mock_dispatcher_ = nullptr;

	// Reset() during construction, and when Reset() is called separately.
	bool handler_ran;
	bool handler_deleted;
	async::WaitBase* last_wait;
	zx_status_t last_status;
	const zx_packet_signal_t* last_signal;
	};

	class LambdaHarness : public Harness {
	public:
	// The on_handler_destruct simulates the dummy_handle/object being deleted as soon as the
	// handler is deleted (which is the soonest it should ever be deleted), and notes that the
	// handler has actually been deleted (not just moved somewhere else).
	LambdaHarness(MockDispatcher* mock_dispatcher, zx_handle_t object = ZX_HANDLE_INVALID,
	zx_signals_t trigger = ZX_SIGNAL_NONE, uint32_t options = 0)
	: Harness(mock_dispatcher),
	wait_{object, trigger, options,
	[this, on_handler_destruct = fit::defer([this] {
	mock_dispatcher_->last_dummy_handle_deleted = dummy_handle;
	handler_deleted = true;
	})](async_dispatcher_t* dispatcher, async::Wait* wait, zx_status_t status,
	const zx_packet_signal_t* signal) {
	Handler(dispatcher, wait, status, signal);
	}} {}

	async::WaitBase& wait() override { return wait_; }
	bool wait_has_handler() override { return wait_.has_handler(); }
	bool wait_retains_handler() override { return true; }

	zx_status_t BeginWait(async_dispatcher_t* dispatcher) override { return wait_.Begin(dispatcher); }

	private:
	async::Wait wait_;
	};

	class LambdaOnceHarness : public Harness {
	public:
	LambdaOnceHarness(MockDispatcher* mock_dispatcher, zx_handle_t object = ZX_HANDLE_INVALID,
	zx_signals_t trigger = ZX_SIGNAL_NONE, uint32_t options = 0)
	: Harness(mock_dispatcher), wait_{object, trigger, options} {}

	async::WaitBase& wait() override { return wait_; }
	bool wait_has_handler() override { return !handler_ran; }
	bool wait_retains_handler() override { return false; }

	zx_status_t BeginWait(async_dispatcher_t* dispatcher) override {
	// The on_handler_destruct simulates the dummy_handle/object being deleted as soon as the
	// handler is deleted (which is the soonest it should ever be deleted), and notes that the
	// handler has actually been deleted (not just moved somewhere else).
	//
	// We only simulate this if there's not already a BeginWait() in progress.
	//
	// While it's true that if a client calls async::WaitOnce::Begin() on a WaitOnce instance that
	// already has a wait in progress, passing in a handler which when deleted will delete the
	// same object as the handler for the wait that's already in progress, that's a client bug.
	// If a client really needed to attempt a second BeginWait() (it really doesn't need to), then
	// it could co-own instead of double-own the object in each of two handlers, where the second
	// handler's immediate deletion during failed BeginWait() would just de-ref, not actually
	// delete.
	auto on_handler_destruct = fit::defer([this, was_fresh_wait = !wait_.is_pending()] {
	if (was_fresh_wait) {
	mock_dispatcher_->last_dummy_handle_deleted = dummy_handle;
	handler_deleted = true;
	}
	});
	return wait_.Begin(dispatcher, [this, on_handler_destruct = std::move(on_handler_destruct)](
	async_dispatcher_t* dispatcher, async::WaitOnce* wait,
	zx_status_t status, const zx_packet_signal_t* signal) {
	Handler(dispatcher, wait, status, signal);
	});
	}

	private:
	async::WaitOnce wait_;
	};

	class MethodHarness : public Harness {
	public:
	MethodHarness(MockDispatcher* mock_dispatcher, zx_handle_t object = ZX_HANDLE_INVALID,
	zx_signals_t trigger = ZX_SIGNAL_NONE, uint32_t options = 0)
	: Harness(mock_dispatcher), wait_{this, object, trigger, options} {}

	async::WaitBase& wait() override { return wait_; }
	bool wait_has_handler() override { return true; }
	bool wait_retains_handler() override { return true; }

	zx_status_t BeginWait(async_dispatcher_t* dispatcher) override { return wait_.Begin(dispatcher); }

	private:
	async::WaitMethod<Harness, &Harness::Handler> wait_;
	};

	TEST(WaitTests, wait_set_handler_test) {
	{
	async::Wait wait;
	EXPECT_FALSE(wait.has_handler());
	EXPECT_FALSE(wait.is_pending());

	wait.set_handler([](async_dispatcher_t* dispatcher, async::Wait* wait, zx_status_t status,
	const zx_packet_signal_t* signal) {});
	EXPECT_TRUE(wait.has_handler());
	}

	{
	async::Wait wait(ZX_HANDLE_INVALID, ZX_SIGNAL_NONE, 0,
	[](async_dispatcher_t* dispatcher, async::Wait* wait, zx_status_t status,
	const zx_packet_signal_t* signal) {});
	EXPECT_TRUE(wait.has_handler());
	EXPECT_FALSE(wait.is_pending());
	}
	}

	template <typename Harness>
	void wait_properties_test() {
	MockDispatcher dispatcher;
	Harness harness(&dispatcher);

	EXPECT_EQ(ZX_HANDLE_INVALID, harness.wait().object());
	harness.wait().set_object(dummy_handle);
	EXPECT_EQ(dummy_handle, harness.wait().object());

	EXPECT_EQ(ZX_SIGNAL_NONE, harness.wait().trigger());
	harness.wait().set_trigger(dummy_trigger);
	EXPECT_EQ(dummy_trigger, harness.wait().trigger());

	EXPECT_EQ(0, harness.wait().options());
	harness.wait().set_options(dummy_options);
	EXPECT_EQ(dummy_options, harness.wait().options());
	}

	template <typename Harness>
	void wait_begin_test() {
	MockDispatcher dispatcher;

	{
	Harness harness(&dispatcher, dummy_handle, dummy_trigger, dummy_options);
	EXPECT_FALSE(harness.wait().is_pending());

	dispatcher.next_status = ZX_OK;
	EXPECT_EQ(ZX_OK, harness.BeginWait(&dispatcher));
	EXPECT_TRUE(harness.wait().is_pending());
	EXPECT_EQ(MockDispatcher::Op::BEGIN_WAIT, dispatcher.last_op);
	EXPECT_EQ(dummy_handle, dispatcher.last_wait->object);
	EXPECT_EQ(dummy_trigger, dispatcher.last_wait->trigger);
	EXPECT_EQ(dummy_options, dispatcher.last_wait->options);
	EXPECT_FALSE(harness.handler_ran);

	harness.Reset();
	dispatcher.last_op = MockDispatcher::Op::NONE;
	EXPECT_EQ(ZX_ERR_ALREADY_EXISTS, harness.BeginWait(&dispatcher));
	EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
	EXPECT_FALSE(harness.handler_ran);
	}
	EXPECT_EQ(MockDispatcher::Op::CANCEL_WAIT, dispatcher.last_op);

	// Pretend like we're using a new handle and happen to get dummy_handle value
	// again.
	dispatcher.last_dummy_handle_deleted = ZX_HANDLE_INVALID;

	{
	Harness harness(&dispatcher, dummy_handle, dummy_trigger, dummy_options);
	EXPECT_FALSE(harness.wait().is_pending());

	dispatcher.next_status = ZX_ERR_BAD_STATE;
	EXPECT_EQ(ZX_ERR_BAD_STATE, harness.BeginWait(&dispatcher));
	EXPECT_EQ(MockDispatcher::Op::BEGIN_WAIT, dispatcher.last_op);
	EXPECT_FALSE(harness.wait().is_pending());
	EXPECT_FALSE(harness.handler_ran);
	}
	EXPECT_EQ(MockDispatcher::Op::BEGIN_WAIT, dispatcher.last_op);
	}

	template <typename Harness>
	void wait_cancel_test() {
	MockDispatcher dispatcher;

	{
	Harness harness(&dispatcher, dummy_handle, dummy_trigger, dummy_options);
	EXPECT_FALSE(harness.wait().is_pending());

	EXPECT_EQ(ZX_ERR_NOT_FOUND, harness.wait().Cancel());
	EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
	EXPECT_FALSE(harness.wait().is_pending());

	EXPECT_EQ(ZX_OK, harness.BeginWait(&dispatcher));
	EXPECT_EQ(MockDispatcher::Op::BEGIN_WAIT, dispatcher.last_op);
	EXPECT_TRUE(harness.wait().is_pending());

	EXPECT_EQ(ZX_OK, harness.wait().Cancel());
	EXPECT_EQ(MockDispatcher::Op::CANCEL_WAIT, dispatcher.last_op);
	EXPECT_FALSE(harness.wait().is_pending());

	dispatcher.last_op = MockDispatcher::Op::NONE;
	EXPECT_EQ(ZX_ERR_NOT_FOUND, harness.wait().Cancel());
	EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
	EXPECT_FALSE(harness.wait().is_pending());
	}
	EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
	}

	template <typename Harness>
	void wait_run_handler_test() {
	MockDispatcher dispatcher;

	{
	Harness harness(&dispatcher, dummy_handle, dummy_trigger, dummy_options);
	EXPECT_FALSE(harness.wait().is_pending());

	EXPECT_EQ(ZX_OK, harness.BeginWait(&dispatcher));
	EXPECT_EQ(MockDispatcher::Op::BEGIN_WAIT, dispatcher.last_op);
	EXPECT_TRUE(harness.wait().is_pending());

	harness.Reset();
	dispatcher.last_wait->handler(&dispatcher, dispatcher.last_wait, ZX_OK, &dummy_signal);
	EXPECT_TRUE(harness.handler_ran);
	EXPECT_EQ(&harness.wait(), harness.last_wait);
	EXPECT_EQ(ZX_OK, harness.last_status);
	EXPECT_EQ(&dummy_signal, harness.last_signal);
	EXPECT_FALSE(harness.wait().is_pending());

	dispatcher.last_op = MockDispatcher::Op::NONE;
	EXPECT_EQ(ZX_ERR_NOT_FOUND, harness.wait().Cancel());
	EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
	EXPECT_FALSE(harness.wait().is_pending());

	EXPECT_EQ(harness.wait_retains_handler(), harness.wait_has_handler());
	EXPECT_EQ(!harness.wait_retains_handler(), harness.handler_deleted);
	}
	EXPECT_EQ(MockDispatcher::Op::NONE, dispatcher.last_op);
	}

	TEST(WaitTests, unsupported_begin_wait_test) {
	async::DispatcherStub dispatcher;
	async_wait_t wait{};
	EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, async_begin_wait(&dispatcher, &wait), "valid args");
	}

	TEST(WaitTests, unsupported_cancel_wait_test) {
	async::DispatcherStub dispatcher;
	async_wait_t wait{};
	EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, async_cancel_wait(&dispatcher, &wait), "valid args");
	}

	} // namespace

	TEST(WaitTests, wait_properties_test_LambdaHarness) { wait_properties_test<LambdaHarness>(); }

	TEST(WaitTests, wait_properties_test_LambdaOnceHarness) {
	wait_properties_test<LambdaOnceHarness>();
	}

	TEST(WaitTests, wait_properties_test_MethodHarness) { wait_properties_test<MethodHarness>(); }

	TEST(WaitTests, wait_begin_test_LambdaHarness) { wait_begin_test<LambdaHarness>(); }

	TEST(WaitTests, wait_begin_test_LambdaOnceHarness) { wait_begin_test<LambdaOnceHarness>(); }

	TEST(WaitTests, wait_begin_test_MethodHarness) { wait_begin_test<MethodHarness>(); }

	TEST(WaitTests, wait_cancel_test_LambdaHarness) { wait_cancel_test<LambdaHarness>(); }

	TEST(WaitTests, wait_cancel_test_LambdaOnceHarness) { wait_cancel_test<LambdaOnceHarness>(); }

	TEST(WaitTests, wait_cancel_test_MethodHarness) { wait_cancel_test<MethodHarness>(); }

	TEST(WaitTests, wait_run_handler_test_LambdaHarness) { wait_run_handler_test<LambdaHarness>(); }

	TEST(WaitTests, wait_run_handler_test_LambdaOnceHarness) {
	wait_run_handler_test<LambdaOnceHarness>();
	}

	TEST(WaitTests, wait_run_handler_test_MethodHarness) { wait_run_handler_test<MethodHarness>(); }