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