base/synchronization/waitable_event_watcher_unittest.cc

   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
   5 #include "base/message_loop.h"
   6 #include "base/synchronization/waitable_event.h"
   7 #include "base/synchronization/waitable_event_watcher.h"
   8 #include "base/threading/platform_thread.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 namespace base {
  12
  13 namespace {
  14
  15 // The message loops on which each waitable event timer should be tested.
  16 const MessageLoop::Type testing_message_loops[] = {
  17   MessageLoop::TYPE_DEFAULT,
  18   MessageLoop::TYPE_IO,
  19 #if !defined(OS_IOS)  // iOS does not allow direct running of the UI loop.
  20   MessageLoop::TYPE_UI,
  21 #endif
  22 };
  23
  24 const int kNumTestingMessageLoops = arraysize(testing_message_loops);
  25
  26 class QuitDelegate : public WaitableEventWatcher::Delegate {
  27  public:
  28   virtual void OnWaitableEventSignaled(WaitableEvent* event) OVERRIDE {
  29     MessageLoop::current()->Quit();
  30   }
  31 };
  32
  33 class DecrementCountDelegate : public WaitableEventWatcher::Delegate {
  34  public:
  35   explicit DecrementCountDelegate(int* counter) : counter_(counter) {
  36   }
  37   virtual void OnWaitableEventSignaled(WaitableEvent* object) OVERRIDE {
  38     --(*counter_);
  39   }
  40  private:
  41   int* counter_;
  42 };
  43
  44 void RunTest_BasicSignal(MessageLoop::Type message_loop_type) {
  45   MessageLoop message_loop(message_loop_type);
  46
  47   // A manual-reset event that is not yet signaled.
  48   WaitableEvent event(true, false);
  49
  50   WaitableEventWatcher watcher;
  51   EXPECT_TRUE(watcher.GetWatchedEvent() == NULL);
  52
  53   QuitDelegate delegate;
  54   watcher.StartWatching(&event, &delegate);
  55   EXPECT_EQ(&event, watcher.GetWatchedEvent());
  56
  57   event.Signal();
  58
  59   MessageLoop::current()->Run();
  60
  61   EXPECT_TRUE(watcher.GetWatchedEvent() == NULL);
  62 }
  63
  64 void RunTest_BasicCancel(MessageLoop::Type message_loop_type) {
  65   MessageLoop message_loop(message_loop_type);
  66
  67   // A manual-reset event that is not yet signaled.
  68   WaitableEvent event(true, false);
  69
  70   WaitableEventWatcher watcher;
  71
  72   QuitDelegate delegate;
  73   watcher.StartWatching(&event, &delegate);
  74
  75   watcher.StopWatching();
  76 }
  77
  78 void RunTest_CancelAfterSet(MessageLoop::Type message_loop_type) {
  79   MessageLoop message_loop(message_loop_type);
  80
  81   // A manual-reset event that is not yet signaled.
  82   WaitableEvent event(true, false);
  83
  84   WaitableEventWatcher watcher;
  85
  86   int counter = 1;
  87   DecrementCountDelegate delegate(&counter);
  88
  89   watcher.StartWatching(&event, &delegate);
  90
  91   event.Signal();
  92
  93   // Let the background thread do its business
  94   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(30));
  95
  96   watcher.StopWatching();
  97
  98   MessageLoop::current()->RunUntilIdle();
  99
 100   // Our delegate should not have fired.
 101   EXPECT_EQ(1, counter);
 102 }
 103
 104 void RunTest_OutlivesMessageLoop(MessageLoop::Type message_loop_type) {
 105   // Simulate a MessageLoop that dies before an WaitableEventWatcher.  This
 106   // ordinarily doesn't happen when people use the Thread class, but it can
 107   // happen when people use the Singleton pattern or atexit.
 108   WaitableEvent event(true, false);
 109   {
 110     WaitableEventWatcher watcher;
 111     {
 112       MessageLoop message_loop(message_loop_type);
 113
 114       QuitDelegate delegate;
 115       watcher.StartWatching(&event, &delegate);
 116     }
 117   }
 118 }
 119
 120 void RunTest_DeleteUnder(MessageLoop::Type message_loop_type) {
 121   // Delete the WaitableEvent out from under the Watcher. This is explictly
 122   // allowed by the interface.
 123
 124   MessageLoop message_loop(message_loop_type);
 125
 126   {
 127     WaitableEventWatcher watcher;
 128
 129     WaitableEvent* event = new WaitableEvent(false, false);
 130     QuitDelegate delegate;
 131     watcher.StartWatching(event, &delegate);
 132     delete event;
 133   }
 134 }
 135
 136 }  // namespace
 137
 138 //-----------------------------------------------------------------------------
 139
 140 TEST(WaitableEventWatcherTest, BasicSignal) {
 141   for (int i = 0; i < kNumTestingMessageLoops; i++) {
 142     RunTest_BasicSignal(testing_message_loops[i]);
 143   }
 144 }
 145
 146 TEST(WaitableEventWatcherTest, BasicCancel) {
 147   for (int i = 0; i < kNumTestingMessageLoops; i++) {
 148     RunTest_BasicCancel(testing_message_loops[i]);
 149   }
 150 }
 151
 152 TEST(WaitableEventWatcherTest, CancelAfterSet) {
 153   for (int i = 0; i < kNumTestingMessageLoops; i++) {
 154     RunTest_CancelAfterSet(testing_message_loops[i]);
 155   }
 156 }
 157
 158 TEST(WaitableEventWatcherTest, OutlivesMessageLoop) {
 159   for (int i = 0; i < kNumTestingMessageLoops; i++) {
 160     RunTest_OutlivesMessageLoop(testing_message_loops[i]);
 161   }
 162 }
 163
 164 #if defined(OS_WIN)
 165 // Crashes sometimes on vista.  http://crbug.com/62119
 166 #define MAYBE_DeleteUnder DISABLED_DeleteUnder
 167 #else
 168 #define MAYBE_DeleteUnder DeleteUnder
 169 #endif
 170 TEST(WaitableEventWatcherTest, MAYBE_DeleteUnder) {
 171   for (int i = 0; i < kNumTestingMessageLoops; i++) {
 172     RunTest_DeleteUnder(testing_message_loops[i]);
 173   }
 174 }
 175
 176 }  // namespace base