base/win/object_watcher_unittest.cc

   1 // Copyright (c) 2011 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 <process.h>
   6
   7 #include "base/message_loop.h"
   8 #include "base/win/object_watcher.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 namespace base {
  12 namespace win {
  13
  14 namespace {
  15
  16 class QuitDelegate : public ObjectWatcher::Delegate {
  17  public:
  18   virtual void OnObjectSignaled(HANDLE object) {
  19     MessageLoop::current()->Quit();
  20   }
  21 };
  22
  23 class DecrementCountDelegate : public ObjectWatcher::Delegate {
  24  public:
  25   explicit DecrementCountDelegate(int* counter) : counter_(counter) {
  26   }
  27   virtual void OnObjectSignaled(HANDLE object) {
  28     --(*counter_);
  29   }
  30  private:
  31   int* counter_;
  32 };
  33
  34 void RunTest_BasicSignal(MessageLoop::Type message_loop_type) {
  35   MessageLoop message_loop(message_loop_type);
  36
  37   ObjectWatcher watcher;
  38   EXPECT_EQ(NULL, watcher.GetWatchedObject());
  39
  40   // A manual-reset event that is not yet signaled.
  41   HANDLE event = CreateEvent(NULL, TRUE, FALSE, NULL);
  42
  43   QuitDelegate delegate;
  44   bool ok = watcher.StartWatching(event, &delegate);
  45   EXPECT_TRUE(ok);
  46   EXPECT_EQ(event, watcher.GetWatchedObject());
  47
  48   SetEvent(event);
  49
  50   MessageLoop::current()->Run();
  51
  52   EXPECT_EQ(NULL, watcher.GetWatchedObject());
  53   CloseHandle(event);
  54 }
  55
  56 void RunTest_BasicCancel(MessageLoop::Type message_loop_type) {
  57   MessageLoop message_loop(message_loop_type);
  58
  59   ObjectWatcher watcher;
  60
  61   // A manual-reset event that is not yet signaled.
  62   HANDLE event = CreateEvent(NULL, TRUE, FALSE, NULL);
  63
  64   QuitDelegate delegate;
  65   bool ok = watcher.StartWatching(event, &delegate);
  66   EXPECT_TRUE(ok);
  67
  68   watcher.StopWatching();
  69
  70   CloseHandle(event);
  71 }
  72
  73 void RunTest_CancelAfterSet(MessageLoop::Type message_loop_type) {
  74   MessageLoop message_loop(message_loop_type);
  75
  76   ObjectWatcher watcher;
  77
  78   int counter = 1;
  79   DecrementCountDelegate delegate(&counter);
  80
  81   // A manual-reset event that is not yet signaled.
  82   HANDLE event = CreateEvent(NULL, TRUE, FALSE, NULL);
  83
  84   bool ok = watcher.StartWatching(event, &delegate);
  85   EXPECT_TRUE(ok);
  86
  87   SetEvent(event);
  88
  89   // Let the background thread do its business
  90   Sleep(30);
  91
  92   watcher.StopWatching();
  93
  94   MessageLoop::current()->RunUntilIdle();
  95
  96   // Our delegate should not have fired.
  97   EXPECT_EQ(1, counter);
  98
  99   CloseHandle(event);
 100 }
 101
 102 void RunTest_SignalBeforeWatch(MessageLoop::Type message_loop_type) {
 103   MessageLoop message_loop(message_loop_type);
 104
 105   ObjectWatcher watcher;
 106
 107   // A manual-reset event that is signaled before we begin watching.
 108   HANDLE event = CreateEvent(NULL, TRUE, TRUE, NULL);
 109
 110   QuitDelegate delegate;
 111   bool ok = watcher.StartWatching(event, &delegate);
 112   EXPECT_TRUE(ok);
 113
 114   MessageLoop::current()->Run();
 115
 116   EXPECT_EQ(NULL, watcher.GetWatchedObject());
 117   CloseHandle(event);
 118 }
 119
 120 void RunTest_OutlivesMessageLoop(MessageLoop::Type message_loop_type) {
 121   // Simulate a MessageLoop that dies before an ObjectWatcher.  This ordinarily
 122   // doesn't happen when people use the Thread class, but it can happen when
 123   // people use the Singleton pattern or atexit.
 124   HANDLE event = CreateEvent(NULL, TRUE, FALSE, NULL);  // not signaled
 125   {
 126     ObjectWatcher watcher;
 127     {
 128       MessageLoop message_loop(message_loop_type);
 129
 130       QuitDelegate delegate;
 131       watcher.StartWatching(event, &delegate);
 132     }
 133   }
 134   CloseHandle(event);
 135 }
 136
 137 }  // namespace
 138
 139 //-----------------------------------------------------------------------------
 140
 141 TEST(ObjectWatcherTest, BasicSignal) {
 142   RunTest_BasicSignal(MessageLoop::TYPE_DEFAULT);
 143   RunTest_BasicSignal(MessageLoop::TYPE_IO);
 144   RunTest_BasicSignal(MessageLoop::TYPE_UI);
 145 }
 146
 147 TEST(ObjectWatcherTest, BasicCancel) {
 148   RunTest_BasicCancel(MessageLoop::TYPE_DEFAULT);
 149   RunTest_BasicCancel(MessageLoop::TYPE_IO);
 150   RunTest_BasicCancel(MessageLoop::TYPE_UI);
 151 }
 152
 153 TEST(ObjectWatcherTest, CancelAfterSet) {
 154   RunTest_CancelAfterSet(MessageLoop::TYPE_DEFAULT);
 155   RunTest_CancelAfterSet(MessageLoop::TYPE_IO);
 156   RunTest_CancelAfterSet(MessageLoop::TYPE_UI);
 157 }
 158
 159 TEST(ObjectWatcherTest, SignalBeforeWatch) {
 160   RunTest_SignalBeforeWatch(MessageLoop::TYPE_DEFAULT);
 161   RunTest_SignalBeforeWatch(MessageLoop::TYPE_IO);
 162   RunTest_SignalBeforeWatch(MessageLoop::TYPE_UI);
 163 }
 164
 165 TEST(ObjectWatcherTest, OutlivesMessageLoop) {
 166   RunTest_OutlivesMessageLoop(MessageLoop::TYPE_DEFAULT);
 167   RunTest_OutlivesMessageLoop(MessageLoop::TYPE_IO);
 168   RunTest_OutlivesMessageLoop(MessageLoop::TYPE_UI);
 169 }
 170
 171 }  // namespace win
 172 }  // namespace base