core_test_base.cc 6.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251
  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. #include "mojo/core/core_test_base.h"
  5. #include "base/memory/raw_ptr.h"
  6. #include <stddef.h>
  7. #include <stdint.h>
  8. #include <vector>
  9. #include "base/check.h"
  10. #include "base/memory/ref_counted.h"
  11. #include "mojo/core/configuration.h"
  12. #include "mojo/core/core.h"
  13. #include "mojo/core/dispatcher.h"
  14. #include "mojo/core/user_message_impl.h"
  15. namespace mojo {
  16. namespace core {
  17. namespace test {
  18. namespace {
  19. // MockDispatcher --------------------------------------------------------------
  20. class MockDispatcher : public Dispatcher {
  21. public:
  22. static scoped_refptr<MockDispatcher> Create(
  23. CoreTestBase::MockHandleInfo* info) {
  24. return base::WrapRefCounted(new MockDispatcher(info));
  25. }
  26. MockDispatcher(const MockDispatcher&) = delete;
  27. MockDispatcher& operator=(const MockDispatcher&) = delete;
  28. // Dispatcher:
  29. Type GetType() const override { return Type::UNKNOWN; }
  30. MojoResult Close() override {
  31. info_->IncrementCloseCallCount();
  32. return MOJO_RESULT_OK;
  33. }
  34. MojoResult WriteMessage(
  35. std::unique_ptr<ports::UserMessageEvent> message_event) override {
  36. info_->IncrementWriteMessageCallCount();
  37. return MOJO_RESULT_OK;
  38. }
  39. MojoResult ReadMessage(
  40. std::unique_ptr<ports::UserMessageEvent>* message_event) override {
  41. info_->IncrementReadMessageCallCount();
  42. return MOJO_RESULT_OK;
  43. }
  44. MojoResult WriteData(const void* elements,
  45. uint32_t* num_bytes,
  46. const MojoWriteDataOptions& options) override {
  47. info_->IncrementWriteDataCallCount();
  48. return MOJO_RESULT_UNIMPLEMENTED;
  49. }
  50. MojoResult BeginWriteData(void** buffer,
  51. uint32_t* buffer_num_bytes) override {
  52. info_->IncrementBeginWriteDataCallCount();
  53. return MOJO_RESULT_UNIMPLEMENTED;
  54. }
  55. MojoResult EndWriteData(uint32_t num_bytes_written) override {
  56. info_->IncrementEndWriteDataCallCount();
  57. return MOJO_RESULT_UNIMPLEMENTED;
  58. }
  59. MojoResult ReadData(const MojoReadDataOptions& options,
  60. void* elements,
  61. uint32_t* num_bytes) override {
  62. info_->IncrementReadDataCallCount();
  63. return MOJO_RESULT_UNIMPLEMENTED;
  64. }
  65. MojoResult BeginReadData(const void** buffer,
  66. uint32_t* buffer_num_bytes) override {
  67. info_->IncrementBeginReadDataCallCount();
  68. return MOJO_RESULT_UNIMPLEMENTED;
  69. }
  70. MojoResult EndReadData(uint32_t num_bytes_read) override {
  71. info_->IncrementEndReadDataCallCount();
  72. return MOJO_RESULT_UNIMPLEMENTED;
  73. }
  74. private:
  75. explicit MockDispatcher(CoreTestBase::MockHandleInfo* info) : info_(info) {
  76. CHECK(info_);
  77. info_->IncrementCtorCallCount();
  78. }
  79. ~MockDispatcher() override { info_->IncrementDtorCallCount(); }
  80. const raw_ptr<CoreTestBase::MockHandleInfo> info_;
  81. };
  82. } // namespace
  83. // CoreTestBase ----------------------------------------------------------------
  84. CoreTestBase::CoreTestBase() = default;
  85. CoreTestBase::~CoreTestBase() = default;
  86. MojoHandle CoreTestBase::CreateMockHandle(CoreTestBase::MockHandleInfo* info) {
  87. scoped_refptr<MockDispatcher> dispatcher = MockDispatcher::Create(info);
  88. return core()->AddDispatcher(dispatcher);
  89. }
  90. Core* CoreTestBase::core() {
  91. return Core::Get();
  92. }
  93. // CoreTestBase_MockHandleInfo -------------------------------------------------
  94. CoreTestBase_MockHandleInfo::CoreTestBase_MockHandleInfo()
  95. : ctor_call_count_(0),
  96. dtor_call_count_(0),
  97. close_call_count_(0),
  98. write_message_call_count_(0),
  99. read_message_call_count_(0),
  100. write_data_call_count_(0),
  101. begin_write_data_call_count_(0),
  102. end_write_data_call_count_(0),
  103. read_data_call_count_(0),
  104. begin_read_data_call_count_(0),
  105. end_read_data_call_count_(0) {}
  106. CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() = default;
  107. unsigned CoreTestBase_MockHandleInfo::GetCtorCallCount() const {
  108. base::AutoLock locker(lock_);
  109. return ctor_call_count_;
  110. }
  111. unsigned CoreTestBase_MockHandleInfo::GetDtorCallCount() const {
  112. base::AutoLock locker(lock_);
  113. return dtor_call_count_;
  114. }
  115. unsigned CoreTestBase_MockHandleInfo::GetCloseCallCount() const {
  116. base::AutoLock locker(lock_);
  117. return close_call_count_;
  118. }
  119. unsigned CoreTestBase_MockHandleInfo::GetWriteMessageCallCount() const {
  120. base::AutoLock locker(lock_);
  121. return write_message_call_count_;
  122. }
  123. unsigned CoreTestBase_MockHandleInfo::GetReadMessageCallCount() const {
  124. base::AutoLock locker(lock_);
  125. return read_message_call_count_;
  126. }
  127. unsigned CoreTestBase_MockHandleInfo::GetWriteDataCallCount() const {
  128. base::AutoLock locker(lock_);
  129. return write_data_call_count_;
  130. }
  131. unsigned CoreTestBase_MockHandleInfo::GetBeginWriteDataCallCount() const {
  132. base::AutoLock locker(lock_);
  133. return begin_write_data_call_count_;
  134. }
  135. unsigned CoreTestBase_MockHandleInfo::GetEndWriteDataCallCount() const {
  136. base::AutoLock locker(lock_);
  137. return end_write_data_call_count_;
  138. }
  139. unsigned CoreTestBase_MockHandleInfo::GetReadDataCallCount() const {
  140. base::AutoLock locker(lock_);
  141. return read_data_call_count_;
  142. }
  143. unsigned CoreTestBase_MockHandleInfo::GetBeginReadDataCallCount() const {
  144. base::AutoLock locker(lock_);
  145. return begin_read_data_call_count_;
  146. }
  147. unsigned CoreTestBase_MockHandleInfo::GetEndReadDataCallCount() const {
  148. base::AutoLock locker(lock_);
  149. return end_read_data_call_count_;
  150. }
  151. void CoreTestBase_MockHandleInfo::IncrementCtorCallCount() {
  152. base::AutoLock locker(lock_);
  153. ctor_call_count_++;
  154. }
  155. void CoreTestBase_MockHandleInfo::IncrementDtorCallCount() {
  156. base::AutoLock locker(lock_);
  157. dtor_call_count_++;
  158. }
  159. void CoreTestBase_MockHandleInfo::IncrementCloseCallCount() {
  160. base::AutoLock locker(lock_);
  161. close_call_count_++;
  162. }
  163. void CoreTestBase_MockHandleInfo::IncrementWriteMessageCallCount() {
  164. base::AutoLock locker(lock_);
  165. write_message_call_count_++;
  166. }
  167. void CoreTestBase_MockHandleInfo::IncrementReadMessageCallCount() {
  168. base::AutoLock locker(lock_);
  169. read_message_call_count_++;
  170. }
  171. void CoreTestBase_MockHandleInfo::IncrementWriteDataCallCount() {
  172. base::AutoLock locker(lock_);
  173. write_data_call_count_++;
  174. }
  175. void CoreTestBase_MockHandleInfo::IncrementBeginWriteDataCallCount() {
  176. base::AutoLock locker(lock_);
  177. begin_write_data_call_count_++;
  178. }
  179. void CoreTestBase_MockHandleInfo::IncrementEndWriteDataCallCount() {
  180. base::AutoLock locker(lock_);
  181. end_write_data_call_count_++;
  182. }
  183. void CoreTestBase_MockHandleInfo::IncrementReadDataCallCount() {
  184. base::AutoLock locker(lock_);
  185. read_data_call_count_++;
  186. }
  187. void CoreTestBase_MockHandleInfo::IncrementBeginReadDataCallCount() {
  188. base::AutoLock locker(lock_);
  189. begin_read_data_call_count_++;
  190. }
  191. void CoreTestBase_MockHandleInfo::IncrementEndReadDataCallCount() {
  192. base::AutoLock locker(lock_);
  193. end_read_data_call_count_++;
  194. }
  195. } // namespace test
  196. } // namespace core
  197. } // namespace mojo