src/mojo/system/core_test_base.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/core_test_base.h"
   6
   7 #include <vector>
   8
   9 #include "base/compiler_specific.h"
  10 #include "base/logging.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "mojo/system/constants.h"
  13 #include "mojo/system/core.h"
  14 #include "mojo/system/dispatcher.h"
  15 #include "mojo/system/memory.h"
  16
  17 namespace mojo {
  18 namespace system {
  19 namespace test {
  20
  21 namespace {
  22
  23 // MockDispatcher --------------------------------------------------------------
  24
  25 class MockDispatcher : public Dispatcher {
  26  public:
  27   explicit MockDispatcher(CoreTestBase::MockHandleInfo* info) : info_(info) {
  28     CHECK(info_);
  29     info_->IncrementCtorCallCount();
  30   }
  31
  32   // |Dispatcher| private methods:
  33   virtual Type GetType() const OVERRIDE { return kTypeUnknown; }
  34
  35  private:
  36   virtual ~MockDispatcher() { info_->IncrementDtorCallCount(); }
  37
  38   // |Dispatcher| protected methods:
  39   virtual void CloseImplNoLock() OVERRIDE {
  40     info_->IncrementCloseCallCount();
  41     lock().AssertAcquired();
  42   }
  43
  44   virtual MojoResult WriteMessageImplNoLock(
  45       UserPointer<const void> bytes,
  46       uint32_t num_bytes,
  47       std::vector<DispatcherTransport>* transports,
  48       MojoWriteMessageFlags /*flags*/) OVERRIDE {
  49     info_->IncrementWriteMessageCallCount();
  50     lock().AssertAcquired();
  51
  52     if (num_bytes > kMaxMessageNumBytes)
  53       return MOJO_RESULT_RESOURCE_EXHAUSTED;
  54
  55     if (transports)
  56       return MOJO_RESULT_UNIMPLEMENTED;
  57
  58     return MOJO_RESULT_OK;
  59   }
  60
  61   virtual MojoResult ReadMessageImplNoLock(
  62       UserPointer<void> bytes,
  63       UserPointer<uint32_t> num_bytes,
  64       DispatcherVector* dispatchers,
  65       uint32_t* num_dispatchers,
  66       MojoReadMessageFlags /*flags*/) OVERRIDE {
  67     info_->IncrementReadMessageCallCount();
  68     lock().AssertAcquired();
  69
  70     if (num_dispatchers) {
  71       *num_dispatchers = 1;
  72       if (dispatchers) {
  73         // Okay to leave an invalid dispatcher.
  74         dispatchers->resize(1);
  75       }
  76     }
  77
  78     return MOJO_RESULT_OK;
  79   }
  80
  81   virtual MojoResult WriteDataImplNoLock(
  82       UserPointer<const void> /*elements*/,
  83       UserPointer<uint32_t> /*num_bytes*/,
  84       MojoWriteDataFlags /*flags*/) OVERRIDE {
  85     info_->IncrementWriteDataCallCount();
  86     lock().AssertAcquired();
  87     return MOJO_RESULT_UNIMPLEMENTED;
  88   }
  89
  90   virtual MojoResult BeginWriteDataImplNoLock(
  91       UserPointer<void*> /*buffer*/,
  92       UserPointer<uint32_t> /*buffer_num_bytes*/,
  93       MojoWriteDataFlags /*flags*/) OVERRIDE {
  94     info_->IncrementBeginWriteDataCallCount();
  95     lock().AssertAcquired();
  96     return MOJO_RESULT_UNIMPLEMENTED;
  97   }
  98
  99   virtual MojoResult EndWriteDataImplNoLock(
 100       uint32_t /*num_bytes_written*/) OVERRIDE {
 101     info_->IncrementEndWriteDataCallCount();
 102     lock().AssertAcquired();
 103     return MOJO_RESULT_UNIMPLEMENTED;
 104   }
 105
 106   virtual MojoResult ReadDataImplNoLock(UserPointer<void> /*elements*/,
 107                                         UserPointer<uint32_t> /*num_bytes*/,
 108                                         MojoReadDataFlags /*flags*/) OVERRIDE {
 109     info_->IncrementReadDataCallCount();
 110     lock().AssertAcquired();
 111     return MOJO_RESULT_UNIMPLEMENTED;
 112   }
 113
 114   virtual MojoResult BeginReadDataImplNoLock(
 115       UserPointer<const void*> /*buffer*/,
 116       UserPointer<uint32_t> /*buffer_num_bytes*/,
 117       MojoReadDataFlags /*flags*/) OVERRIDE {
 118     info_->IncrementBeginReadDataCallCount();
 119     lock().AssertAcquired();
 120     return MOJO_RESULT_UNIMPLEMENTED;
 121   }
 122
 123   virtual MojoResult EndReadDataImplNoLock(
 124       uint32_t /*num_bytes_read*/) OVERRIDE {
 125     info_->IncrementEndReadDataCallCount();
 126     lock().AssertAcquired();
 127     return MOJO_RESULT_UNIMPLEMENTED;
 128   }
 129
 130   virtual MojoResult AddWaiterImplNoLock(
 131       Waiter* /*waiter*/,
 132       MojoHandleSignals /*signals*/,
 133       uint32_t /*context*/,
 134       HandleSignalsState* signals_state) OVERRIDE {
 135     info_->IncrementAddWaiterCallCount();
 136     lock().AssertAcquired();
 137     if (signals_state)
 138       *signals_state = HandleSignalsState();
 139     return MOJO_RESULT_FAILED_PRECONDITION;
 140   }
 141
 142   virtual void RemoveWaiterImplNoLock(
 143       Waiter* /*waiter*/,
 144       HandleSignalsState* signals_state) OVERRIDE {
 145     info_->IncrementRemoveWaiterCallCount();
 146     lock().AssertAcquired();
 147     if (signals_state)
 148       *signals_state = HandleSignalsState();
 149   }
 150
 151   virtual void CancelAllWaitersNoLock() OVERRIDE {
 152     info_->IncrementCancelAllWaitersCallCount();
 153     lock().AssertAcquired();
 154   }
 155
 156   virtual scoped_refptr<Dispatcher>
 157   CreateEquivalentDispatcherAndCloseImplNoLock() OVERRIDE {
 158     return scoped_refptr<Dispatcher>(new MockDispatcher(info_));
 159   }
 160
 161   CoreTestBase::MockHandleInfo* const info_;
 162
 163   DISALLOW_COPY_AND_ASSIGN(MockDispatcher);
 164 };
 165
 166 }  // namespace
 167
 168 // CoreTestBase ----------------------------------------------------------------
 169
 170 CoreTestBase::CoreTestBase() {
 171 }
 172
 173 CoreTestBase::~CoreTestBase() {
 174 }
 175
 176 void CoreTestBase::SetUp() {
 177   core_ = new Core();
 178 }
 179
 180 void CoreTestBase::TearDown() {
 181   delete core_;
 182   core_ = NULL;
 183 }
 184
 185 MojoHandle CoreTestBase::CreateMockHandle(CoreTestBase::MockHandleInfo* info) {
 186   CHECK(core_);
 187   scoped_refptr<MockDispatcher> dispatcher(new MockDispatcher(info));
 188   return core_->AddDispatcher(dispatcher);
 189 }
 190
 191 // CoreTestBase_MockHandleInfo -------------------------------------------------
 192
 193 CoreTestBase_MockHandleInfo::CoreTestBase_MockHandleInfo()
 194     : ctor_call_count_(0),
 195       dtor_call_count_(0),
 196       close_call_count_(0),
 197       write_message_call_count_(0),
 198       read_message_call_count_(0),
 199       write_data_call_count_(0),
 200       begin_write_data_call_count_(0),
 201       end_write_data_call_count_(0),
 202       read_data_call_count_(0),
 203       begin_read_data_call_count_(0),
 204       end_read_data_call_count_(0),
 205       add_waiter_call_count_(0),
 206       remove_waiter_call_count_(0),
 207       cancel_all_waiters_call_count_(0) {
 208 }
 209
 210 CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() {
 211 }
 212
 213 unsigned CoreTestBase_MockHandleInfo::GetCtorCallCount() const {
 214   base::AutoLock locker(lock_);
 215   return ctor_call_count_;
 216 }
 217
 218 unsigned CoreTestBase_MockHandleInfo::GetDtorCallCount() const {
 219   base::AutoLock locker(lock_);
 220   return dtor_call_count_;
 221 }
 222
 223 unsigned CoreTestBase_MockHandleInfo::GetCloseCallCount() const {
 224   base::AutoLock locker(lock_);
 225   return close_call_count_;
 226 }
 227
 228 unsigned CoreTestBase_MockHandleInfo::GetWriteMessageCallCount() const {
 229   base::AutoLock locker(lock_);
 230   return write_message_call_count_;
 231 }
 232
 233 unsigned CoreTestBase_MockHandleInfo::GetReadMessageCallCount() const {
 234   base::AutoLock locker(lock_);
 235   return read_message_call_count_;
 236 }
 237
 238 unsigned CoreTestBase_MockHandleInfo::GetWriteDataCallCount() const {
 239   base::AutoLock locker(lock_);
 240   return write_data_call_count_;
 241 }
 242
 243 unsigned CoreTestBase_MockHandleInfo::GetBeginWriteDataCallCount() const {
 244   base::AutoLock locker(lock_);
 245   return begin_write_data_call_count_;
 246 }
 247
 248 unsigned CoreTestBase_MockHandleInfo::GetEndWriteDataCallCount() const {
 249   base::AutoLock locker(lock_);
 250   return end_write_data_call_count_;
 251 }
 252
 253 unsigned CoreTestBase_MockHandleInfo::GetReadDataCallCount() const {
 254   base::AutoLock locker(lock_);
 255   return read_data_call_count_;
 256 }
 257
 258 unsigned CoreTestBase_MockHandleInfo::GetBeginReadDataCallCount() const {
 259   base::AutoLock locker(lock_);
 260   return begin_read_data_call_count_;
 261 }
 262
 263 unsigned CoreTestBase_MockHandleInfo::GetEndReadDataCallCount() const {
 264   base::AutoLock locker(lock_);
 265   return end_read_data_call_count_;
 266 }
 267
 268 unsigned CoreTestBase_MockHandleInfo::GetAddWaiterCallCount() const {
 269   base::AutoLock locker(lock_);
 270   return add_waiter_call_count_;
 271 }
 272
 273 unsigned CoreTestBase_MockHandleInfo::GetRemoveWaiterCallCount() const {
 274   base::AutoLock locker(lock_);
 275   return remove_waiter_call_count_;
 276 }
 277
 278 unsigned CoreTestBase_MockHandleInfo::GetCancelAllWaitersCallCount() const {
 279   base::AutoLock locker(lock_);
 280   return cancel_all_waiters_call_count_;
 281 }
 282
 283 void CoreTestBase_MockHandleInfo::IncrementCtorCallCount() {
 284   base::AutoLock locker(lock_);
 285   ctor_call_count_++;
 286 }
 287
 288 void CoreTestBase_MockHandleInfo::IncrementDtorCallCount() {
 289   base::AutoLock locker(lock_);
 290   dtor_call_count_++;
 291 }
 292
 293 void CoreTestBase_MockHandleInfo::IncrementCloseCallCount() {
 294   base::AutoLock locker(lock_);
 295   close_call_count_++;
 296 }
 297
 298 void CoreTestBase_MockHandleInfo::IncrementWriteMessageCallCount() {
 299   base::AutoLock locker(lock_);
 300   write_message_call_count_++;
 301 }
 302
 303 void CoreTestBase_MockHandleInfo::IncrementReadMessageCallCount() {
 304   base::AutoLock locker(lock_);
 305   read_message_call_count_++;
 306 }
 307
 308 void CoreTestBase_MockHandleInfo::IncrementWriteDataCallCount() {
 309   base::AutoLock locker(lock_);
 310   write_data_call_count_++;
 311 }
 312
 313 void CoreTestBase_MockHandleInfo::IncrementBeginWriteDataCallCount() {
 314   base::AutoLock locker(lock_);
 315   begin_write_data_call_count_++;
 316 }
 317
 318 void CoreTestBase_MockHandleInfo::IncrementEndWriteDataCallCount() {
 319   base::AutoLock locker(lock_);
 320   end_write_data_call_count_++;
 321 }
 322
 323 void CoreTestBase_MockHandleInfo::IncrementReadDataCallCount() {
 324   base::AutoLock locker(lock_);
 325   read_data_call_count_++;
 326 }
 327
 328 void CoreTestBase_MockHandleInfo::IncrementBeginReadDataCallCount() {
 329   base::AutoLock locker(lock_);
 330   begin_read_data_call_count_++;
 331 }
 332
 333 void CoreTestBase_MockHandleInfo::IncrementEndReadDataCallCount() {
 334   base::AutoLock locker(lock_);
 335   end_read_data_call_count_++;
 336 }
 337
 338 void CoreTestBase_MockHandleInfo::IncrementAddWaiterCallCount() {
 339   base::AutoLock locker(lock_);
 340   add_waiter_call_count_++;
 341 }
 342
 343 void CoreTestBase_MockHandleInfo::IncrementRemoveWaiterCallCount() {
 344   base::AutoLock locker(lock_);
 345   remove_waiter_call_count_++;
 346 }
 347
 348 void CoreTestBase_MockHandleInfo::IncrementCancelAllWaitersCallCount() {
 349   base::AutoLock locker(lock_);
 350   cancel_all_waiters_call_count_++;
 351 }
 352
 353 }  // namespace test
 354 }  // namespace system
 355 }  // namespace mojo