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