src/mojo/public/environment/tests/async_waiter_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "mojo/public/environment/default_async_waiter.h"
   6
   7 #include <string>
   8
   9 #include "mojo/public/environment/environment.h"
  10 #include "mojo/public/system/core_cpp.h"
  11 #include "mojo/public/system/macros.h"
  12 #include "mojo/public/tests/test_utils.h"
  13 #include "mojo/public/utility/run_loop.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace mojo {
  17 namespace {
  18
  19 class TestAsyncWaitCallback {
  20  public:
  21   TestAsyncWaitCallback() : result_count_(0), last_result_(MOJO_RESULT_OK) {
  22   }
  23   virtual ~TestAsyncWaitCallback() {}
  24
  25   int result_count() const { return result_count_; }
  26
  27   MojoResult last_result() const { return last_result_; }
  28
  29   // MojoAsyncWaitCallback:
  30   static void OnHandleReady(void* closure, MojoResult result) {
  31     TestAsyncWaitCallback* self = static_cast<TestAsyncWaitCallback*>(closure);
  32     self->result_count_++;
  33     self->last_result_ = result;
  34   }
  35
  36  private:
  37   int result_count_;
  38   MojoResult last_result_;
  39
  40   MOJO_DISALLOW_COPY_AND_ASSIGN(TestAsyncWaitCallback);
  41 };
  42
  43 MojoAsyncWaitID CallAsyncWait(const Handle& handle,
  44                               MojoWaitFlags flags,
  45                               TestAsyncWaitCallback* callback) {
  46   MojoAsyncWaiter* waiter = GetDefaultAsyncWaiter();
  47   return waiter->AsyncWait(waiter,
  48                            handle.value(),
  49                            flags,
  50                            MOJO_DEADLINE_INDEFINITE,
  51                            &TestAsyncWaitCallback::OnHandleReady,
  52                            callback);
  53 }
  54
  55 void CallCancelWait(MojoAsyncWaitID wait_id) {
  56   MojoAsyncWaiter* waiter = GetDefaultAsyncWaiter();
  57   waiter->CancelWait(waiter, wait_id);
  58 }
  59
  60 class AsyncWaiterTest : public testing::Test {
  61  public:
  62   AsyncWaiterTest() {}
  63
  64  private:
  65   Environment environment_;
  66   RunLoop run_loop_;
  67
  68   MOJO_DISALLOW_COPY_AND_ASSIGN(AsyncWaiterTest);
  69 };
  70
  71 // Verifies AsyncWaitCallback is notified when pipe is ready.
  72 TEST_F(AsyncWaiterTest, CallbackNotified) {
  73   TestAsyncWaitCallback callback;
  74   MessagePipe test_pipe;
  75   EXPECT_TRUE(test::WriteTextMessage(test_pipe.handle1.get(), std::string()));
  76
  77   CallAsyncWait(test_pipe.handle0.get(),
  78                 MOJO_WAIT_FLAG_READABLE,
  79                 &callback);
  80   RunLoop::current()->Run();
  81   EXPECT_EQ(1, callback.result_count());
  82   EXPECT_EQ(MOJO_RESULT_OK, callback.last_result());
  83 }
  84
  85 // Verifies 2 AsyncWaitCallbacks are notified when there pipes are ready.
  86 TEST_F(AsyncWaiterTest, TwoCallbacksNotified) {
  87   TestAsyncWaitCallback callback1;
  88   TestAsyncWaitCallback callback2;
  89   MessagePipe test_pipe1;
  90   MessagePipe test_pipe2;
  91   EXPECT_TRUE(test::WriteTextMessage(test_pipe1.handle1.get(), std::string()));
  92   EXPECT_TRUE(test::WriteTextMessage(test_pipe2.handle1.get(), std::string()));
  93
  94   CallAsyncWait(test_pipe1.handle0.get(), MOJO_WAIT_FLAG_READABLE, &callback1);
  95   CallAsyncWait(test_pipe2.handle0.get(), MOJO_WAIT_FLAG_READABLE, &callback2);
  96
  97   RunLoop::current()->Run();
  98   EXPECT_EQ(1, callback1.result_count());
  99   EXPECT_EQ(MOJO_RESULT_OK, callback1.last_result());
 100   EXPECT_EQ(1, callback2.result_count());
 101   EXPECT_EQ(MOJO_RESULT_OK, callback2.last_result());
 102 }
 103
 104 // Verifies cancel works.
 105 TEST_F(AsyncWaiterTest, CancelCallback) {
 106   TestAsyncWaitCallback callback;
 107   MessagePipe test_pipe;
 108   EXPECT_TRUE(test::WriteTextMessage(test_pipe.handle1.get(), std::string()));
 109
 110   CallCancelWait(
 111       CallAsyncWait(test_pipe.handle0.get(),
 112                     MOJO_WAIT_FLAG_READABLE,
 113                     &callback));
 114   RunLoop::current()->Run();
 115   EXPECT_EQ(0, callback.result_count());
 116 }
 117
 118 }  // namespace
 119 }  // namespace mojo