waitable_event_unittest.cc 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266
  1. // Copyright (c) 2012 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 "base/synchronization/waitable_event.h"
  5. #include <stddef.h>
  6. #include <algorithm>
  7. #include "base/compiler_specific.h"
  8. #include "base/memory/raw_ptr.h"
  9. #include "base/threading/platform_thread.h"
  10. #include "base/time/time.h"
  11. #include "build/build_config.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. namespace base {
  14. TEST(WaitableEventTest, ManualBasics) {
  15. WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
  16. WaitableEvent::InitialState::NOT_SIGNALED);
  17. EXPECT_FALSE(event.IsSignaled());
  18. event.Signal();
  19. EXPECT_TRUE(event.IsSignaled());
  20. EXPECT_TRUE(event.IsSignaled());
  21. event.Reset();
  22. EXPECT_FALSE(event.IsSignaled());
  23. EXPECT_FALSE(event.TimedWait(Milliseconds(10)));
  24. event.Signal();
  25. event.Wait();
  26. EXPECT_TRUE(event.TimedWait(Milliseconds(10)));
  27. }
  28. TEST(WaitableEventTest, ManualInitiallySignaled) {
  29. WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
  30. WaitableEvent::InitialState::SIGNALED);
  31. EXPECT_TRUE(event.IsSignaled());
  32. EXPECT_TRUE(event.IsSignaled());
  33. event.Reset();
  34. EXPECT_FALSE(event.IsSignaled());
  35. EXPECT_FALSE(event.IsSignaled());
  36. event.Signal();
  37. event.Wait();
  38. EXPECT_TRUE(event.IsSignaled());
  39. EXPECT_TRUE(event.IsSignaled());
  40. }
  41. TEST(WaitableEventTest, AutoBasics) {
  42. WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
  43. WaitableEvent::InitialState::NOT_SIGNALED);
  44. EXPECT_FALSE(event.IsSignaled());
  45. event.Signal();
  46. EXPECT_TRUE(event.IsSignaled());
  47. EXPECT_FALSE(event.IsSignaled());
  48. event.Reset();
  49. EXPECT_FALSE(event.IsSignaled());
  50. EXPECT_FALSE(event.TimedWait(Milliseconds(10)));
  51. event.Signal();
  52. event.Wait();
  53. EXPECT_FALSE(event.TimedWait(Milliseconds(10)));
  54. event.Signal();
  55. EXPECT_TRUE(event.TimedWait(Milliseconds(10)));
  56. }
  57. TEST(WaitableEventTest, AutoInitiallySignaled) {
  58. WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
  59. WaitableEvent::InitialState::SIGNALED);
  60. EXPECT_TRUE(event.IsSignaled());
  61. EXPECT_FALSE(event.IsSignaled());
  62. event.Signal();
  63. EXPECT_TRUE(event.IsSignaled());
  64. EXPECT_FALSE(event.IsSignaled());
  65. }
  66. TEST(WaitableEventTest, WaitManyShortcut) {
  67. WaitableEvent* ev[5];
  68. for (auto*& i : ev) {
  69. i = new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
  70. WaitableEvent::InitialState::NOT_SIGNALED);
  71. }
  72. ev[3]->Signal();
  73. EXPECT_EQ(WaitableEvent::WaitMany(ev, 5), 3u);
  74. ev[3]->Signal();
  75. EXPECT_EQ(WaitableEvent::WaitMany(ev, 5), 3u);
  76. ev[4]->Signal();
  77. EXPECT_EQ(WaitableEvent::WaitMany(ev, 5), 4u);
  78. ev[0]->Signal();
  79. EXPECT_EQ(WaitableEvent::WaitMany(ev, 5), 0u);
  80. for (auto* i : ev)
  81. delete i;
  82. }
  83. TEST(WaitableEventTest, WaitManyLeftToRight) {
  84. WaitableEvent* ev[5];
  85. for (auto*& i : ev) {
  86. i = new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
  87. WaitableEvent::InitialState::NOT_SIGNALED);
  88. }
  89. // Test for consistent left-to-right return behavior across all permutations
  90. // of the input array. This is to verify that only the indices -- and not
  91. // the WaitableEvents' addresses -- are relevant in determining who wins when
  92. // multiple events are signaled.
  93. std::sort(ev, ev + 5);
  94. do {
  95. ev[0]->Signal();
  96. ev[1]->Signal();
  97. EXPECT_EQ(0u, WaitableEvent::WaitMany(ev, 5));
  98. ev[2]->Signal();
  99. EXPECT_EQ(1u, WaitableEvent::WaitMany(ev, 5));
  100. EXPECT_EQ(2u, WaitableEvent::WaitMany(ev, 5));
  101. ev[3]->Signal();
  102. ev[4]->Signal();
  103. ev[0]->Signal();
  104. EXPECT_EQ(0u, WaitableEvent::WaitMany(ev, 5));
  105. EXPECT_EQ(3u, WaitableEvent::WaitMany(ev, 5));
  106. ev[2]->Signal();
  107. EXPECT_EQ(2u, WaitableEvent::WaitMany(ev, 5));
  108. EXPECT_EQ(4u, WaitableEvent::WaitMany(ev, 5));
  109. } while (std::next_permutation(ev, ev + 5));
  110. for (auto* i : ev)
  111. delete i;
  112. }
  113. class WaitableEventSignaler : public PlatformThread::Delegate {
  114. public:
  115. WaitableEventSignaler(TimeDelta delay, WaitableEvent* event)
  116. : delay_(delay),
  117. event_(event) {
  118. }
  119. void ThreadMain() override {
  120. PlatformThread::Sleep(delay_);
  121. event_->Signal();
  122. }
  123. private:
  124. const TimeDelta delay_;
  125. raw_ptr<WaitableEvent> event_;
  126. };
  127. // Tests that a WaitableEvent can be safely deleted when |Wait| is done without
  128. // additional synchronization.
  129. TEST(WaitableEventTest, WaitAndDelete) {
  130. WaitableEvent* ev =
  131. new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
  132. WaitableEvent::InitialState::NOT_SIGNALED);
  133. WaitableEventSignaler signaler(Milliseconds(10), ev);
  134. PlatformThreadHandle thread;
  135. PlatformThread::Create(0, &signaler, &thread);
  136. ev->Wait();
  137. delete ev;
  138. PlatformThread::Join(thread);
  139. }
  140. // Tests that a WaitableEvent can be safely deleted when |WaitMany| is done
  141. // without additional synchronization.
  142. TEST(WaitableEventTest, WaitMany) {
  143. WaitableEvent* ev[5];
  144. for (auto*& i : ev) {
  145. i = new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
  146. WaitableEvent::InitialState::NOT_SIGNALED);
  147. }
  148. WaitableEventSignaler signaler(Milliseconds(10), ev[2]);
  149. PlatformThreadHandle thread;
  150. PlatformThread::Create(0, &signaler, &thread);
  151. size_t index = WaitableEvent::WaitMany(ev, 5);
  152. for (auto* i : ev)
  153. delete i;
  154. PlatformThread::Join(thread);
  155. EXPECT_EQ(2u, index);
  156. }
  157. // Tests that using TimeDelta::Max() on TimedWait() is not the same as passing
  158. // a timeout of 0. (crbug.com/465948)
  159. TEST(WaitableEventTest, TimedWait) {
  160. WaitableEvent* ev =
  161. new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
  162. WaitableEvent::InitialState::NOT_SIGNALED);
  163. TimeDelta thread_delay = Milliseconds(10);
  164. WaitableEventSignaler signaler(thread_delay, ev);
  165. PlatformThreadHandle thread;
  166. TimeTicks start = TimeTicks::Now();
  167. PlatformThread::Create(0, &signaler, &thread);
  168. EXPECT_TRUE(ev->TimedWait(TimeDelta::Max()));
  169. EXPECT_GE(TimeTicks::Now() - start, thread_delay);
  170. delete ev;
  171. PlatformThread::Join(thread);
  172. }
  173. // Tests that a sub-ms TimedWait doesn't time out promptly.
  174. TEST(WaitableEventTest, SubMsTimedWait) {
  175. WaitableEvent ev(WaitableEvent::ResetPolicy::AUTOMATIC,
  176. WaitableEvent::InitialState::NOT_SIGNALED);
  177. TimeDelta delay = Microseconds(900);
  178. TimeTicks start_time = TimeTicks::Now();
  179. ev.TimedWait(delay);
  180. EXPECT_GE(TimeTicks::Now() - start_time, delay);
  181. }
  182. // Tests that timeouts of zero return immediately (true if already signaled,
  183. // false otherwise).
  184. TEST(WaitableEventTest, ZeroTimeout) {
  185. WaitableEvent ev;
  186. TimeTicks start_time = TimeTicks::Now();
  187. EXPECT_FALSE(ev.TimedWait(TimeDelta()));
  188. EXPECT_LT(TimeTicks::Now() - start_time, Milliseconds(1));
  189. ev.Signal();
  190. start_time = TimeTicks::Now();
  191. EXPECT_TRUE(ev.TimedWait(TimeDelta()));
  192. EXPECT_LT(TimeTicks::Now() - start_time, Milliseconds(1));
  193. }
  194. // Same as ZeroTimeout for negative timeouts.
  195. TEST(WaitableEventTest, NegativeTimeout) {
  196. WaitableEvent ev;
  197. TimeTicks start_time = TimeTicks::Now();
  198. EXPECT_FALSE(ev.TimedWait(Milliseconds(-10)));
  199. EXPECT_LT(TimeTicks::Now() - start_time, Milliseconds(1));
  200. ev.Signal();
  201. start_time = TimeTicks::Now();
  202. EXPECT_TRUE(ev.TimedWait(Milliseconds(-10)));
  203. EXPECT_LT(TimeTicks::Now() - start_time, Milliseconds(1));
  204. }
  205. } // namespace base