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
18namespace mojo {
19namespace system {
20namespace test {
21
22namespace {
23
24// MockDispatcher --------------------------------------------------------------
25
26class 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
171CoreTestBase::CoreTestBase() {
172}
173
174CoreTestBase::~CoreTestBase() {
175}
176
177void CoreTestBase::SetUp() {
178  core_ = new Core(scoped_ptr<embedder::PlatformSupport>(
179      new embedder::SimplePlatformSupport()));
180}
181
182void CoreTestBase::TearDown() {
183  delete core_;
184  core_ = nullptr;
185}
186
187MojoHandle 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
195CoreTestBase_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
212CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() {
213}
214
215unsigned CoreTestBase_MockHandleInfo::GetCtorCallCount() const {
216  base::AutoLock locker(lock_);
217  return ctor_call_count_;
218}
219
220unsigned CoreTestBase_MockHandleInfo::GetDtorCallCount() const {
221  base::AutoLock locker(lock_);
222  return dtor_call_count_;
223}
224
225unsigned CoreTestBase_MockHandleInfo::GetCloseCallCount() const {
226  base::AutoLock locker(lock_);
227  return close_call_count_;
228}
229
230unsigned CoreTestBase_MockHandleInfo::GetWriteMessageCallCount() const {
231  base::AutoLock locker(lock_);
232  return write_message_call_count_;
233}
234
235unsigned CoreTestBase_MockHandleInfo::GetReadMessageCallCount() const {
236  base::AutoLock locker(lock_);
237  return read_message_call_count_;
238}
239
240unsigned CoreTestBase_MockHandleInfo::GetWriteDataCallCount() const {
241  base::AutoLock locker(lock_);
242  return write_data_call_count_;
243}
244
245unsigned CoreTestBase_MockHandleInfo::GetBeginWriteDataCallCount() const {
246  base::AutoLock locker(lock_);
247  return begin_write_data_call_count_;
248}
249
250unsigned CoreTestBase_MockHandleInfo::GetEndWriteDataCallCount() const {
251  base::AutoLock locker(lock_);
252  return end_write_data_call_count_;
253}
254
255unsigned CoreTestBase_MockHandleInfo::GetReadDataCallCount() const {
256  base::AutoLock locker(lock_);
257  return read_data_call_count_;
258}
259
260unsigned CoreTestBase_MockHandleInfo::GetBeginReadDataCallCount() const {
261  base::AutoLock locker(lock_);
262  return begin_read_data_call_count_;
263}
264
265unsigned CoreTestBase_MockHandleInfo::GetEndReadDataCallCount() const {
266  base::AutoLock locker(lock_);
267  return end_read_data_call_count_;
268}
269
270unsigned CoreTestBase_MockHandleInfo::GetAddWaiterCallCount() const {
271  base::AutoLock locker(lock_);
272  return add_waiter_call_count_;
273}
274
275unsigned CoreTestBase_MockHandleInfo::GetRemoveWaiterCallCount() const {
276  base::AutoLock locker(lock_);
277  return remove_waiter_call_count_;
278}
279
280unsigned CoreTestBase_MockHandleInfo::GetCancelAllWaitersCallCount() const {
281  base::AutoLock locker(lock_);
282  return cancel_all_waiters_call_count_;
283}
284
285void CoreTestBase_MockHandleInfo::IncrementCtorCallCount() {
286  base::AutoLock locker(lock_);
287  ctor_call_count_++;
288}
289
290void CoreTestBase_MockHandleInfo::IncrementDtorCallCount() {
291  base::AutoLock locker(lock_);
292  dtor_call_count_++;
293}
294
295void CoreTestBase_MockHandleInfo::IncrementCloseCallCount() {
296  base::AutoLock locker(lock_);
297  close_call_count_++;
298}
299
300void CoreTestBase_MockHandleInfo::IncrementWriteMessageCallCount() {
301  base::AutoLock locker(lock_);
302  write_message_call_count_++;
303}
304
305void CoreTestBase_MockHandleInfo::IncrementReadMessageCallCount() {
306  base::AutoLock locker(lock_);
307  read_message_call_count_++;
308}
309
310void CoreTestBase_MockHandleInfo::IncrementWriteDataCallCount() {
311  base::AutoLock locker(lock_);
312  write_data_call_count_++;
313}
314
315void CoreTestBase_MockHandleInfo::IncrementBeginWriteDataCallCount() {
316  base::AutoLock locker(lock_);
317  begin_write_data_call_count_++;
318}
319
320void CoreTestBase_MockHandleInfo::IncrementEndWriteDataCallCount() {
321  base::AutoLock locker(lock_);
322  end_write_data_call_count_++;
323}
324
325void CoreTestBase_MockHandleInfo::IncrementReadDataCallCount() {
326  base::AutoLock locker(lock_);
327  read_data_call_count_++;
328}
329
330void CoreTestBase_MockHandleInfo::IncrementBeginReadDataCallCount() {
331  base::AutoLock locker(lock_);
332  begin_read_data_call_count_++;
333}
334
335void CoreTestBase_MockHandleInfo::IncrementEndReadDataCallCount() {
336  base::AutoLock locker(lock_);
337  end_read_data_call_count_++;
338}
339
340void CoreTestBase_MockHandleInfo::IncrementAddWaiterCallCount() {
341  base::AutoLock locker(lock_);
342  add_waiter_call_count_++;
343}
344
345void CoreTestBase_MockHandleInfo::IncrementRemoveWaiterCallCount() {
346  base::AutoLock locker(lock_);
347  remove_waiter_call_count_++;
348}
349
350void 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
358