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