src/mojo/system/dispatcher_unittest.cc

   1 // Copyright 2013 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/system/dispatcher.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_vector.h"
  10 #include "base/synchronization/waitable_event.h"
  11 #include "base/threading/simple_thread.h"
  12 #include "mojo/system/waiter.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace mojo {
  16 namespace system {
  17 namespace {
  18
  19 // Trivial subclass that makes the constructor public.
  20 class TrivialDispatcher : public Dispatcher {
  21  public:
  22   TrivialDispatcher() {}
  23
  24  private:
  25   friend class base::RefCountedThreadSafe<TrivialDispatcher>;
  26   virtual ~TrivialDispatcher() {}
  27
  28   virtual scoped_refptr<Dispatcher>
  29       CreateEquivalentDispatcherAndCloseImplNoLock() OVERRIDE {
  30     return scoped_refptr<Dispatcher>(new TrivialDispatcher());
  31   }
  32
  33   DISALLOW_COPY_AND_ASSIGN(TrivialDispatcher);
  34 };
  35
  36 TEST(DispatcherTest, Basic) {
  37   scoped_refptr<Dispatcher> d(new TrivialDispatcher());
  38
  39   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  40             d->WriteMessage(NULL, 0, NULL, MOJO_WRITE_MESSAGE_FLAG_NONE));
  41   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  42             d->ReadMessage(NULL, NULL, NULL, NULL,
  43                            MOJO_WRITE_MESSAGE_FLAG_NONE));
  44   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  45             d->WriteData(NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE));
  46   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  47             d->BeginWriteData(NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE));
  48   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  49             d->EndWriteData(0));
  50   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  51             d->ReadData(NULL, NULL, MOJO_READ_DATA_FLAG_NONE));
  52   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  53             d->BeginReadData(NULL, NULL, MOJO_READ_DATA_FLAG_NONE));
  54   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  55             d->EndReadData(0));
  56   Waiter w;
  57   w.Init();
  58   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
  59             d->AddWaiter(&w, MOJO_WAIT_FLAG_EVERYTHING, 0));
  60   // Okay to remove even if it wasn't added (or was already removed).
  61   d->RemoveWaiter(&w);
  62   d->RemoveWaiter(&w);
  63
  64   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
  65
  66   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  67             d->WriteMessage(NULL, 0, NULL, MOJO_WRITE_MESSAGE_FLAG_NONE));
  68   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  69             d->ReadMessage(NULL, NULL, NULL, NULL,
  70                            MOJO_WRITE_MESSAGE_FLAG_NONE));
  71   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  72             d->WriteData(NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE));
  73   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  74             d->BeginWriteData(NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE));
  75   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  76             d->EndWriteData(0));
  77   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  78             d->ReadData(NULL, NULL, MOJO_READ_DATA_FLAG_NONE));
  79   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  80             d->BeginReadData(NULL, NULL, MOJO_READ_DATA_FLAG_NONE));
  81   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  82             d->EndReadData(0));
  83   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  84             d->AddWaiter(&w, MOJO_WAIT_FLAG_EVERYTHING, 0));
  85   d->RemoveWaiter(&w);
  86 }
  87
  88 class ThreadSafetyStressThread : public base::SimpleThread {
  89  public:
  90   enum DispatcherOp {
  91     CLOSE = 0,
  92     WRITE_MESSAGE,
  93     READ_MESSAGE,
  94     WRITE_DATA,
  95     BEGIN_WRITE_DATA,
  96     END_WRITE_DATA,
  97     READ_DATA,
  98     BEGIN_READ_DATA,
  99     END_READ_DATA,
 100     ADD_WAITER,
 101     REMOVE_WAITER,
 102
 103     DISPATCHER_OP_COUNT
 104   };
 105
 106   ThreadSafetyStressThread(base::WaitableEvent* event,
 107                            scoped_refptr<Dispatcher> dispatcher,
 108                            DispatcherOp op)
 109       : base::SimpleThread("thread_safety_stress_thread"),
 110         event_(event),
 111         dispatcher_(dispatcher),
 112         op_(op) {
 113     CHECK_LE(0, op_);
 114     CHECK_LT(op_, DISPATCHER_OP_COUNT);
 115   }
 116
 117   virtual ~ThreadSafetyStressThread() {
 118     Join();
 119   }
 120
 121  private:
 122   virtual void Run() OVERRIDE {
 123     event_->Wait();
 124
 125     waiter_.Init();
 126     switch(op_) {
 127       case CLOSE: {
 128         MojoResult r = dispatcher_->Close();
 129         EXPECT_TRUE(r == MOJO_RESULT_OK || r == MOJO_RESULT_INVALID_ARGUMENT)
 130             << "Result: " << r;
 131         break;
 132       }
 133       case WRITE_MESSAGE:
 134         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 135                   dispatcher_->WriteMessage(NULL, 0, NULL,
 136                                             MOJO_WRITE_MESSAGE_FLAG_NONE));
 137         break;
 138       case READ_MESSAGE:
 139         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 140                   dispatcher_->ReadMessage(NULL, NULL, NULL, NULL,
 141                                            MOJO_WRITE_MESSAGE_FLAG_NONE));
 142         break;
 143       case WRITE_DATA:
 144         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 145                   dispatcher_->WriteData(NULL, NULL,
 146                                          MOJO_WRITE_DATA_FLAG_NONE));
 147         break;
 148       case BEGIN_WRITE_DATA:
 149         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 150                   dispatcher_->BeginWriteData(NULL, NULL,
 151                                               MOJO_WRITE_DATA_FLAG_NONE));
 152         break;
 153       case END_WRITE_DATA:
 154         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 155                   dispatcher_->EndWriteData(0));
 156         break;
 157       case READ_DATA:
 158         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 159                   dispatcher_->ReadData(NULL, NULL, MOJO_READ_DATA_FLAG_NONE));
 160         break;
 161       case BEGIN_READ_DATA:
 162         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 163                   dispatcher_->BeginReadData(NULL, NULL,
 164                                              MOJO_READ_DATA_FLAG_NONE));
 165         break;
 166       case END_READ_DATA:
 167         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 168                   dispatcher_->EndReadData(0));
 169         break;
 170       case ADD_WAITER: {
 171         MojoResult r = dispatcher_->AddWaiter(&waiter_,
 172                                               MOJO_WAIT_FLAG_EVERYTHING, 0);
 173         EXPECT_TRUE(r == MOJO_RESULT_FAILED_PRECONDITION ||
 174                     r == MOJO_RESULT_INVALID_ARGUMENT);
 175         break;
 176       }
 177       case REMOVE_WAITER:
 178         dispatcher_->RemoveWaiter(&waiter_);
 179         break;
 180       default:
 181         NOTREACHED();
 182         break;
 183     }
 184
 185     // Always try to remove the waiter, in case we added it.
 186     dispatcher_->RemoveWaiter(&waiter_);
 187   }
 188
 189   base::WaitableEvent* const event_;
 190   const scoped_refptr<Dispatcher> dispatcher_;
 191   const DispatcherOp op_;
 192
 193   Waiter waiter_;
 194
 195   DISALLOW_COPY_AND_ASSIGN(ThreadSafetyStressThread);
 196 };
 197
 198 TEST(DispatcherTest, ThreadSafetyStress) {
 199   static const size_t kRepeatCount = 20;
 200   static const size_t kNumThreads = 100;
 201
 202   for (size_t i = 0; i < kRepeatCount; i++) {
 203     // Manual reset, not initially signalled.
 204     base::WaitableEvent event(true, false);
 205     scoped_refptr<Dispatcher> d(new TrivialDispatcher());
 206
 207     {
 208       ScopedVector<ThreadSafetyStressThread> threads;
 209       for (size_t j = 0; j < kNumThreads; j++) {
 210         ThreadSafetyStressThread::DispatcherOp op =
 211             static_cast<ThreadSafetyStressThread::DispatcherOp>(
 212                 (i+j) % ThreadSafetyStressThread::DISPATCHER_OP_COUNT);
 213         threads.push_back(new ThreadSafetyStressThread(&event, d, op));
 214         threads.back()->Start();
 215       }
 216       event.Signal();  // Kicks off real work on the threads.
 217     }  // Joins all the threads.
 218
 219     // One of the threads should already have closed the dispatcher.
 220     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->Close());
 221   }
 222 }
 223
 224 TEST(DispatcherTest, ThreadSafetyStressNoClose) {
 225   static const size_t kRepeatCount = 20;
 226   static const size_t kNumThreads = 100;
 227
 228   for (size_t i = 0; i < kRepeatCount; i++) {
 229     // Manual reset, not initially signalled.
 230     base::WaitableEvent event(true, false);
 231     scoped_refptr<Dispatcher> d(new TrivialDispatcher());
 232
 233     {
 234       ScopedVector<ThreadSafetyStressThread> threads;
 235       for (size_t j = 0; j < kNumThreads; j++) {
 236         ThreadSafetyStressThread::DispatcherOp op =
 237             static_cast<ThreadSafetyStressThread::DispatcherOp>(
 238                 (i+j) % (ThreadSafetyStressThread::DISPATCHER_OP_COUNT-1) + 1);
 239         threads.push_back(new ThreadSafetyStressThread(&event, d, op));
 240         threads.back()->Start();
 241       }
 242       event.Signal();  // Kicks off real work on the threads.
 243     }  // Joins all the threads.
 244
 245     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
 246   }
 247 }
 248
 249 }  // namespace
 250 }  // namespace system
 251 }  // namespace mojo