initializer_unittest.cc 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235
  1. // Copyright (c) 2022 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 "testing/gtest/include/gtest/gtest.h"
  5. #include "base/allocator/dispatcher/configuration.h"
  6. #include "base/allocator/dispatcher/initializer.h"
  7. #include "base/allocator/dispatcher/testing/observer_mock.h"
  8. #include "base/allocator/dispatcher/testing/tools.h"
  9. #include <functional>
  10. #include <map>
  11. #include <tuple>
  12. namespace base::allocator::dispatcher {
  13. namespace testing {
  14. // A mock Dispatcher for testing. Since Initializer and Dispatcher rely on
  15. // templating, we can't employ GoogleMocks for mocking. The mock dispatcher
  16. // records the number of invocations of Initialize for a given tuple of
  17. // observers.
  18. struct Dispatcher {
  19. Dispatcher() = default;
  20. ~Dispatcher() {
  21. for (const auto& reset_data : reseter_) {
  22. reset_data.second();
  23. }
  24. }
  25. template <typename... Observers>
  26. void Initialize(const std::tuple<Observers*...>& observers) {
  27. ++total_number_of_inits_;
  28. ++(GetInitCounterForObservers(observers));
  29. }
  30. size_t GetTotalInitCounter() const { return total_number_of_inits_; }
  31. template <typename... Observers>
  32. size_t& GetInitCounterForObservers(
  33. const std::tuple<Observers*...>& observers) {
  34. static std::map<std::tuple<Observers*...>, size_t>
  35. observer_init_counter_map;
  36. reseter_[&observer_init_counter_map] = []() {
  37. observer_init_counter_map.clear();
  38. };
  39. return observer_init_counter_map[observers];
  40. }
  41. size_t total_number_of_inits_ = 0;
  42. std::map<void*, std::function<void()>> reseter_;
  43. };
  44. } // namespace testing
  45. using testing::ObserverMock;
  46. struct BaseAllocatorDispatcherInitializerTest : public ::testing::Test {};
  47. TEST_F(BaseAllocatorDispatcherInitializerTest, VerifyEmptyInitializer) {
  48. const auto initializer = CreateInitializer();
  49. EXPECT_EQ(initializer.GetOptionalObservers(), std::make_tuple());
  50. EXPECT_EQ(initializer.GetMandatoryObservers(), std::make_tuple());
  51. }
  52. TEST_F(BaseAllocatorDispatcherInitializerTest, VerifySettingOptionalObservers) {
  53. ObserverMock<int> optional_observer_1;
  54. ObserverMock<float> optional_observer_2;
  55. ObserverMock<size_t> optional_observer_3;
  56. auto initializer_1 = CreateInitializer().SetOptionalObservers(
  57. &optional_observer_1, &optional_observer_2);
  58. EXPECT_EQ(initializer_1.GetOptionalObservers(),
  59. std::make_tuple(&optional_observer_1, &optional_observer_2));
  60. EXPECT_EQ(initializer_1.GetMandatoryObservers(), std::make_tuple());
  61. auto initializer_2 = initializer_1.SetOptionalObservers(&optional_observer_3);
  62. EXPECT_EQ(initializer_2.GetOptionalObservers(),
  63. std::make_tuple(&optional_observer_3));
  64. EXPECT_EQ(initializer_2.GetMandatoryObservers(), std::make_tuple());
  65. auto initializer_3 = initializer_2.SetOptionalObservers();
  66. EXPECT_EQ(initializer_3.GetOptionalObservers(), std::make_tuple());
  67. EXPECT_EQ(initializer_3.GetMandatoryObservers(), std::make_tuple());
  68. }
  69. TEST_F(BaseAllocatorDispatcherInitializerTest, VerifyAddingOptionalObservers) {
  70. ObserverMock<int> optional_observer_1;
  71. ObserverMock<float> optional_observer_2;
  72. ObserverMock<size_t> optional_observer_3;
  73. auto initializer_1 = CreateInitializer().AddOptionalObservers(
  74. &optional_observer_1, &optional_observer_2);
  75. EXPECT_EQ(initializer_1.GetOptionalObservers(),
  76. std::make_tuple(&optional_observer_1, &optional_observer_2));
  77. EXPECT_EQ(initializer_1.GetMandatoryObservers(), std::make_tuple());
  78. auto initializer_2 = initializer_1.AddOptionalObservers(&optional_observer_3);
  79. EXPECT_EQ(initializer_2.GetOptionalObservers(),
  80. std::make_tuple(&optional_observer_1, &optional_observer_2,
  81. &optional_observer_3));
  82. EXPECT_EQ(initializer_2.GetMandatoryObservers(), std::make_tuple());
  83. auto initializer_3 = initializer_2.AddOptionalObservers();
  84. EXPECT_EQ(initializer_3.GetOptionalObservers(),
  85. std::make_tuple(&optional_observer_1, &optional_observer_2,
  86. &optional_observer_3));
  87. EXPECT_EQ(initializer_3.GetMandatoryObservers(), std::make_tuple());
  88. auto initializer_4 = initializer_3.SetOptionalObservers();
  89. EXPECT_EQ(initializer_4.GetOptionalObservers(), std::make_tuple());
  90. EXPECT_EQ(initializer_4.GetMandatoryObservers(), std::make_tuple());
  91. }
  92. TEST_F(BaseAllocatorDispatcherInitializerTest,
  93. VerifySettingMandatoryObservers) {
  94. ObserverMock<int> mandatory_observer_1;
  95. ObserverMock<float> mandatory_observer_2;
  96. ObserverMock<size_t> mandatory_observer_3;
  97. auto initializer_1 = CreateInitializer().SetMandatoryObservers(
  98. &mandatory_observer_1, &mandatory_observer_2);
  99. EXPECT_EQ(initializer_1.GetMandatoryObservers(),
  100. std::make_tuple(&mandatory_observer_1, &mandatory_observer_2));
  101. EXPECT_EQ(initializer_1.GetOptionalObservers(), std::make_tuple());
  102. auto initializer_2 =
  103. initializer_1.SetMandatoryObservers(&mandatory_observer_3);
  104. EXPECT_EQ(initializer_2.GetMandatoryObservers(),
  105. std::make_tuple(&mandatory_observer_3));
  106. EXPECT_EQ(initializer_2.GetOptionalObservers(), std::make_tuple());
  107. auto initializer_3 = initializer_2.SetMandatoryObservers();
  108. EXPECT_EQ(initializer_3.GetMandatoryObservers(), std::make_tuple());
  109. EXPECT_EQ(initializer_3.GetOptionalObservers(), std::make_tuple());
  110. }
  111. TEST_F(BaseAllocatorDispatcherInitializerTest, VerifyAddingMandatoryObservers) {
  112. ObserverMock<int> mandatory_observer_1;
  113. ObserverMock<float> mandatory_observer_2;
  114. ObserverMock<size_t> mandatory_observer_3;
  115. auto initializer_1 = CreateInitializer().AddMandatoryObservers(
  116. &mandatory_observer_1, &mandatory_observer_2);
  117. EXPECT_EQ(initializer_1.GetMandatoryObservers(),
  118. std::make_tuple(&mandatory_observer_1, &mandatory_observer_2));
  119. EXPECT_EQ(initializer_1.GetOptionalObservers(), std::make_tuple());
  120. auto initializer_2 =
  121. initializer_1.AddMandatoryObservers(&mandatory_observer_3);
  122. EXPECT_EQ(initializer_2.GetMandatoryObservers(),
  123. std::make_tuple(&mandatory_observer_1, &mandatory_observer_2,
  124. &mandatory_observer_3));
  125. EXPECT_EQ(initializer_2.GetOptionalObservers(), std::make_tuple());
  126. auto initializer_3 = initializer_2.AddMandatoryObservers();
  127. EXPECT_EQ(initializer_3.GetMandatoryObservers(),
  128. std::make_tuple(&mandatory_observer_1, &mandatory_observer_2,
  129. &mandatory_observer_3));
  130. EXPECT_EQ(initializer_3.GetOptionalObservers(), std::make_tuple());
  131. auto initializer_4 = initializer_3.SetMandatoryObservers();
  132. EXPECT_EQ(initializer_4.GetMandatoryObservers(), std::make_tuple());
  133. EXPECT_EQ(initializer_4.GetOptionalObservers(), std::make_tuple());
  134. }
  135. TEST_F(BaseAllocatorDispatcherInitializerTest, VerifyBasicInitialization) {
  136. ObserverMock<int> optional_observer_1;
  137. ObserverMock<float> optional_observer_2;
  138. ObserverMock<size_t> mandatory_observer_1;
  139. ObserverMock<double> mandatory_observer_2;
  140. testing::Dispatcher test_dispatcher;
  141. CreateInitializer()
  142. .SetMandatoryObservers(&mandatory_observer_1, &mandatory_observer_2)
  143. .SetOptionalObservers(&optional_observer_1, &optional_observer_2)
  144. .DoInitialize(test_dispatcher);
  145. const auto observer_ptrs =
  146. std::make_tuple(&mandatory_observer_1, &mandatory_observer_2,
  147. &optional_observer_1, &optional_observer_2);
  148. EXPECT_EQ(1ul, test_dispatcher.GetInitCounterForObservers(observer_ptrs));
  149. }
  150. TEST_F(BaseAllocatorDispatcherInitializerTest,
  151. VerifyInitializationWithMandatoryNullObservers) {
  152. ObserverMock<int> optional_observer_1;
  153. ObserverMock<float> optional_observer_2;
  154. ObserverMock<size_t> mandatory_observer;
  155. ObserverMock<double>* mandatory_null_observer = nullptr;
  156. testing::Dispatcher test_dispatcher;
  157. CreateInitializer()
  158. .SetMandatoryObservers(&mandatory_observer, mandatory_null_observer)
  159. .SetOptionalObservers(&optional_observer_1, &optional_observer_2)
  160. .DoInitialize(test_dispatcher);
  161. // For mandatory observers being null we expect them to be passed straight
  162. // down to the dispatcher, which will then perform a check of ALL observers.
  163. const auto valid_observer_ptrs =
  164. std::make_tuple(&mandatory_observer, mandatory_null_observer,
  165. &optional_observer_1, &optional_observer_2);
  166. EXPECT_EQ(1ul, test_dispatcher.GetTotalInitCounter());
  167. EXPECT_EQ(1ul,
  168. test_dispatcher.GetInitCounterForObservers(valid_observer_ptrs));
  169. }
  170. TEST_F(BaseAllocatorDispatcherInitializerTest,
  171. VerifyInitializationWithOptionalNullObservers) {
  172. ObserverMock<int> optional_observer;
  173. ObserverMock<float>* optional_null_observer = nullptr;
  174. ObserverMock<size_t> mandatory_observer_1;
  175. ObserverMock<double> mandatory_observer_2;
  176. testing::Dispatcher test_dispatcher;
  177. CreateInitializer()
  178. .SetMandatoryObservers(&mandatory_observer_1, &mandatory_observer_2)
  179. .SetOptionalObservers(&optional_observer, optional_null_observer)
  180. .DoInitialize(test_dispatcher);
  181. const auto valid_observer_ptrs = std::make_tuple(
  182. &mandatory_observer_1, &mandatory_observer_2, &optional_observer);
  183. EXPECT_EQ(1ul, test_dispatcher.GetTotalInitCounter());
  184. EXPECT_EQ(1ul,
  185. test_dispatcher.GetInitCounterForObservers(valid_observer_ptrs));
  186. }
  187. } // namespace base::allocator::dispatcher