1 //
2 // Copyright 2010 The Android Open Source Project
3 //
4
5 #include <utils/Looper.h>
6 #include <utils/Timers.h>
7 #include <utils/StopWatch.h>
8 #include <gtest/gtest.h>
9 #include <unistd.h>
10 #include <time.h>
11
12 #include "TestHelpers.h"
13
14 // # of milliseconds to fudge stopwatch measurements
15 #define TIMING_TOLERANCE_MS 25
16
17 namespace android {
18
19 enum {
20 MSG_TEST1 = 1,
21 MSG_TEST2 = 2,
22 MSG_TEST3 = 3,
23 MSG_TEST4 = 4,
24 };
25
26 class DelayedWake : public DelayedTask {
27 sp<Looper> mLooper;
28
29 public:
DelayedWake(int delayMillis,const sp<Looper> looper)30 DelayedWake(int delayMillis, const sp<Looper> looper) :
31 DelayedTask(delayMillis), mLooper(looper) {
32 }
33
34 protected:
doTask()35 virtual void doTask() {
36 mLooper->wake();
37 }
38 };
39
40 class DelayedWriteSignal : public DelayedTask {
41 Pipe* mPipe;
42
43 public:
DelayedWriteSignal(int delayMillis,Pipe * pipe)44 DelayedWriteSignal(int delayMillis, Pipe* pipe) :
45 DelayedTask(delayMillis), mPipe(pipe) {
46 }
47
48 protected:
doTask()49 virtual void doTask() {
50 mPipe->writeSignal();
51 }
52 };
53
54 class CallbackHandler {
55 public:
setCallback(const sp<Looper> & looper,int fd,int events)56 void setCallback(const sp<Looper>& looper, int fd, int events) {
57 looper->addFd(fd, 0, events, staticHandler, this);
58 }
59
60 protected:
~CallbackHandler()61 virtual ~CallbackHandler() { }
62
63 virtual int handler(int fd, int events) = 0;
64
65 private:
staticHandler(int fd,int events,void * data)66 static int staticHandler(int fd, int events, void* data) {
67 return static_cast<CallbackHandler*>(data)->handler(fd, events);
68 }
69 };
70
71 class StubCallbackHandler : public CallbackHandler {
72 public:
73 int nextResult;
74 int callbackCount;
75
76 int fd;
77 int events;
78
StubCallbackHandler(int nextResult)79 explicit StubCallbackHandler(int nextResult) : nextResult(nextResult),
80 callbackCount(0), fd(-1), events(-1) {
81 }
82
83 protected:
handler(int fd,int events)84 virtual int handler(int fd, int events) {
85 callbackCount += 1;
86 this->fd = fd;
87 this->events = events;
88 return nextResult;
89 }
90 };
91
92 class StubMessageHandler : public MessageHandler {
93 public:
94 Vector<Message> messages;
95
handleMessage(const Message & message)96 virtual void handleMessage(const Message& message) {
97 messages.push(message);
98 }
99 };
100
101 class LooperTest : public testing::Test {
102 protected:
103 sp<Looper> mLooper;
104
SetUp()105 virtual void SetUp() {
106 mLooper = new Looper(true);
107 }
108
TearDown()109 virtual void TearDown() {
110 mLooper.clear();
111 }
112 };
113
114
TEST_F(LooperTest,PollOnce_WhenNonZeroTimeoutAndNotAwoken_WaitsForTimeout)115 TEST_F(LooperTest, PollOnce_WhenNonZeroTimeoutAndNotAwoken_WaitsForTimeout) {
116 StopWatch stopWatch("pollOnce");
117 int result = mLooper->pollOnce(100);
118 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
119
120 EXPECT_NEAR(100, elapsedMillis, TIMING_TOLERANCE_MS)
121 << "elapsed time should approx. equal timeout";
122 EXPECT_EQ(Looper::POLL_TIMEOUT, result)
123 << "pollOnce result should be LOOPER_POLL_TIMEOUT";
124 }
125
TEST_F(LooperTest,PollOnce_WhenNonZeroTimeoutAndAwokenBeforeWaiting_ImmediatelyReturns)126 TEST_F(LooperTest, PollOnce_WhenNonZeroTimeoutAndAwokenBeforeWaiting_ImmediatelyReturns) {
127 mLooper->wake();
128
129 StopWatch stopWatch("pollOnce");
130 int result = mLooper->pollOnce(1000);
131 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
132
133 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
134 << "elapsed time should approx. zero because wake() was called before waiting";
135 EXPECT_EQ(Looper::POLL_WAKE, result)
136 << "pollOnce result should be Looper::POLL_CALLBACK because loop was awoken";
137 }
138
TEST_F(LooperTest,PollOnce_WhenNonZeroTimeoutAndAwokenWhileWaiting_PromptlyReturns)139 TEST_F(LooperTest, PollOnce_WhenNonZeroTimeoutAndAwokenWhileWaiting_PromptlyReturns) {
140 sp<DelayedWake> delayedWake = new DelayedWake(100, mLooper);
141 delayedWake->run("LooperTest");
142
143 StopWatch stopWatch("pollOnce");
144 int result = mLooper->pollOnce(1000);
145 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
146
147 EXPECT_NEAR(100, elapsedMillis, TIMING_TOLERANCE_MS)
148 << "elapsed time should approx. equal wake delay";
149 EXPECT_EQ(Looper::POLL_WAKE, result)
150 << "pollOnce result should be Looper::POLL_CALLBACK because loop was awoken";
151 }
152
TEST_F(LooperTest,PollOnce_WhenZeroTimeoutAndNoRegisteredFDs_ImmediatelyReturns)153 TEST_F(LooperTest, PollOnce_WhenZeroTimeoutAndNoRegisteredFDs_ImmediatelyReturns) {
154 StopWatch stopWatch("pollOnce");
155 int result = mLooper->pollOnce(0);
156 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
157
158 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
159 << "elapsed time should be approx. zero";
160 EXPECT_EQ(Looper::POLL_TIMEOUT, result)
161 << "pollOnce result should be Looper::POLL_TIMEOUT";
162 }
163
TEST_F(LooperTest,PollOnce_WhenZeroTimeoutAndNoSignalledFDs_ImmediatelyReturns)164 TEST_F(LooperTest, PollOnce_WhenZeroTimeoutAndNoSignalledFDs_ImmediatelyReturns) {
165 Pipe pipe;
166 StubCallbackHandler handler(true);
167
168 handler.setCallback(mLooper, pipe.receiveFd, Looper::EVENT_INPUT);
169
170 StopWatch stopWatch("pollOnce");
171 int result = mLooper->pollOnce(0);
172 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
173
174 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
175 << "elapsed time should be approx. zero";
176 EXPECT_EQ(Looper::POLL_TIMEOUT, result)
177 << "pollOnce result should be Looper::POLL_TIMEOUT";
178 EXPECT_EQ(0, handler.callbackCount)
179 << "callback should not have been invoked because FD was not signalled";
180 }
181
TEST_F(LooperTest,PollOnce_WhenZeroTimeoutAndSignalledFD_ImmediatelyInvokesCallbackAndReturns)182 TEST_F(LooperTest, PollOnce_WhenZeroTimeoutAndSignalledFD_ImmediatelyInvokesCallbackAndReturns) {
183 Pipe pipe;
184 StubCallbackHandler handler(true);
185
186 ASSERT_EQ(OK, pipe.writeSignal());
187 handler.setCallback(mLooper, pipe.receiveFd, Looper::EVENT_INPUT);
188
189 StopWatch stopWatch("pollOnce");
190 int result = mLooper->pollOnce(0);
191 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
192
193 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
194 << "elapsed time should be approx. zero";
195 EXPECT_EQ(Looper::POLL_CALLBACK, result)
196 << "pollOnce result should be Looper::POLL_CALLBACK because FD was signalled";
197 EXPECT_EQ(1, handler.callbackCount)
198 << "callback should be invoked exactly once";
199 EXPECT_EQ(pipe.receiveFd, handler.fd)
200 << "callback should have received pipe fd as parameter";
201 EXPECT_EQ(Looper::EVENT_INPUT, handler.events)
202 << "callback should have received Looper::EVENT_INPUT as events";
203 }
204
TEST_F(LooperTest,PollOnce_WhenNonZeroTimeoutAndNoSignalledFDs_WaitsForTimeoutAndReturns)205 TEST_F(LooperTest, PollOnce_WhenNonZeroTimeoutAndNoSignalledFDs_WaitsForTimeoutAndReturns) {
206 Pipe pipe;
207 StubCallbackHandler handler(true);
208
209 handler.setCallback(mLooper, pipe.receiveFd, Looper::EVENT_INPUT);
210
211 StopWatch stopWatch("pollOnce");
212 int result = mLooper->pollOnce(100);
213 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
214
215 EXPECT_NEAR(100, elapsedMillis, TIMING_TOLERANCE_MS)
216 << "elapsed time should approx. equal timeout";
217 EXPECT_EQ(Looper::POLL_TIMEOUT, result)
218 << "pollOnce result should be Looper::POLL_TIMEOUT";
219 EXPECT_EQ(0, handler.callbackCount)
220 << "callback should not have been invoked because FD was not signalled";
221 }
222
TEST_F(LooperTest,PollOnce_WhenNonZeroTimeoutAndSignalledFDBeforeWaiting_ImmediatelyInvokesCallbackAndReturns)223 TEST_F(LooperTest, PollOnce_WhenNonZeroTimeoutAndSignalledFDBeforeWaiting_ImmediatelyInvokesCallbackAndReturns) {
224 Pipe pipe;
225 StubCallbackHandler handler(true);
226
227 pipe.writeSignal();
228 handler.setCallback(mLooper, pipe.receiveFd, Looper::EVENT_INPUT);
229
230 StopWatch stopWatch("pollOnce");
231 int result = mLooper->pollOnce(100);
232 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
233
234 ASSERT_EQ(OK, pipe.readSignal())
235 << "signal should actually have been written";
236 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
237 << "elapsed time should be approx. zero";
238 EXPECT_EQ(Looper::POLL_CALLBACK, result)
239 << "pollOnce result should be Looper::POLL_CALLBACK because FD was signalled";
240 EXPECT_EQ(1, handler.callbackCount)
241 << "callback should be invoked exactly once";
242 EXPECT_EQ(pipe.receiveFd, handler.fd)
243 << "callback should have received pipe fd as parameter";
244 EXPECT_EQ(Looper::EVENT_INPUT, handler.events)
245 << "callback should have received Looper::EVENT_INPUT as events";
246 }
247
TEST_F(LooperTest,PollOnce_WhenNonZeroTimeoutAndSignalledFDWhileWaiting_PromptlyInvokesCallbackAndReturns)248 TEST_F(LooperTest, PollOnce_WhenNonZeroTimeoutAndSignalledFDWhileWaiting_PromptlyInvokesCallbackAndReturns) {
249 Pipe pipe;
250 StubCallbackHandler handler(true);
251 sp<DelayedWriteSignal> delayedWriteSignal = new DelayedWriteSignal(100, & pipe);
252
253 handler.setCallback(mLooper, pipe.receiveFd, Looper::EVENT_INPUT);
254 delayedWriteSignal->run("LooperTest");
255
256 StopWatch stopWatch("pollOnce");
257 int result = mLooper->pollOnce(1000);
258 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
259
260 ASSERT_EQ(OK, pipe.readSignal())
261 << "signal should actually have been written";
262 EXPECT_NEAR(100, elapsedMillis, TIMING_TOLERANCE_MS)
263 << "elapsed time should approx. equal signal delay";
264 EXPECT_EQ(Looper::POLL_CALLBACK, result)
265 << "pollOnce result should be Looper::POLL_CALLBACK because FD was signalled";
266 EXPECT_EQ(1, handler.callbackCount)
267 << "callback should be invoked exactly once";
268 EXPECT_EQ(pipe.receiveFd, handler.fd)
269 << "callback should have received pipe fd as parameter";
270 EXPECT_EQ(Looper::EVENT_INPUT, handler.events)
271 << "callback should have received Looper::EVENT_INPUT as events";
272 }
273
TEST_F(LooperTest,PollOnce_WhenCallbackAddedThenRemoved_CallbackShouldNotBeInvoked)274 TEST_F(LooperTest, PollOnce_WhenCallbackAddedThenRemoved_CallbackShouldNotBeInvoked) {
275 Pipe pipe;
276 StubCallbackHandler handler(true);
277
278 handler.setCallback(mLooper, pipe.receiveFd, Looper::EVENT_INPUT);
279 pipe.writeSignal(); // would cause FD to be considered signalled
280 mLooper->removeFd(pipe.receiveFd);
281
282 StopWatch stopWatch("pollOnce");
283 int result = mLooper->pollOnce(100);
284 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
285
286 ASSERT_EQ(OK, pipe.readSignal())
287 << "signal should actually have been written";
288 EXPECT_NEAR(100, elapsedMillis, TIMING_TOLERANCE_MS)
289 << "elapsed time should approx. equal timeout because FD was no longer registered";
290 EXPECT_EQ(Looper::POLL_TIMEOUT, result)
291 << "pollOnce result should be Looper::POLL_TIMEOUT";
292 EXPECT_EQ(0, handler.callbackCount)
293 << "callback should not be invoked";
294 }
295
TEST_F(LooperTest,PollOnce_WhenCallbackReturnsFalse_CallbackShouldNotBeInvokedAgainLater)296 TEST_F(LooperTest, PollOnce_WhenCallbackReturnsFalse_CallbackShouldNotBeInvokedAgainLater) {
297 Pipe pipe;
298 StubCallbackHandler handler(false);
299
300 handler.setCallback(mLooper, pipe.receiveFd, Looper::EVENT_INPUT);
301
302 // First loop: Callback is registered and FD is signalled.
303 pipe.writeSignal();
304
305 StopWatch stopWatch("pollOnce");
306 int result = mLooper->pollOnce(0);
307 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
308
309 ASSERT_EQ(OK, pipe.readSignal())
310 << "signal should actually have been written";
311 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
312 << "elapsed time should approx. equal zero because FD was already signalled";
313 EXPECT_EQ(Looper::POLL_CALLBACK, result)
314 << "pollOnce result should be Looper::POLL_CALLBACK because FD was signalled";
315 EXPECT_EQ(1, handler.callbackCount)
316 << "callback should be invoked";
317
318 // Second loop: Callback is no longer registered and FD is signalled.
319 pipe.writeSignal();
320
321 stopWatch.reset();
322 result = mLooper->pollOnce(0);
323 elapsedMillis = ns2ms(stopWatch.elapsedTime());
324
325 ASSERT_EQ(OK, pipe.readSignal())
326 << "signal should actually have been written";
327 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
328 << "elapsed time should approx. equal zero because timeout was zero";
329 EXPECT_EQ(Looper::POLL_TIMEOUT, result)
330 << "pollOnce result should be Looper::POLL_TIMEOUT";
331 EXPECT_EQ(1, handler.callbackCount)
332 << "callback should not be invoked this time";
333 }
334
TEST_F(LooperTest,PollOnce_WhenNonCallbackFdIsSignalled_ReturnsIdent)335 TEST_F(LooperTest, PollOnce_WhenNonCallbackFdIsSignalled_ReturnsIdent) {
336 const int expectedIdent = 5;
337 void* expectedData = this;
338
339 Pipe pipe;
340
341 pipe.writeSignal();
342 mLooper->addFd(pipe.receiveFd, expectedIdent, Looper::EVENT_INPUT, NULL, expectedData);
343
344 StopWatch stopWatch("pollOnce");
345 int fd;
346 int events;
347 void* data;
348 int result = mLooper->pollOnce(100, &fd, &events, &data);
349 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
350
351 ASSERT_EQ(OK, pipe.readSignal())
352 << "signal should actually have been written";
353 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
354 << "elapsed time should be approx. zero";
355 EXPECT_EQ(expectedIdent, result)
356 << "pollOnce result should be the ident of the FD that was signalled";
357 EXPECT_EQ(pipe.receiveFd, fd)
358 << "pollOnce should have returned the received pipe fd";
359 EXPECT_EQ(Looper::EVENT_INPUT, events)
360 << "pollOnce should have returned Looper::EVENT_INPUT as events";
361 EXPECT_EQ(expectedData, data)
362 << "pollOnce should have returned the data";
363 }
364
TEST_F(LooperTest,AddFd_WhenCallbackAdded_ReturnsOne)365 TEST_F(LooperTest, AddFd_WhenCallbackAdded_ReturnsOne) {
366 Pipe pipe;
367 int result = mLooper->addFd(pipe.receiveFd, 0, Looper::EVENT_INPUT, NULL, NULL);
368
369 EXPECT_EQ(1, result)
370 << "addFd should return 1 because FD was added";
371 }
372
TEST_F(LooperTest,AddFd_WhenIdentIsNegativeAndCallbackIsNull_ReturnsError)373 TEST_F(LooperTest, AddFd_WhenIdentIsNegativeAndCallbackIsNull_ReturnsError) {
374 Pipe pipe;
375 int result = mLooper->addFd(pipe.receiveFd, -1, Looper::EVENT_INPUT, NULL, NULL);
376
377 EXPECT_EQ(-1, result)
378 << "addFd should return -1 because arguments were invalid";
379 }
380
TEST_F(LooperTest,AddFd_WhenNoCallbackAndAllowNonCallbacksIsFalse_ReturnsError)381 TEST_F(LooperTest, AddFd_WhenNoCallbackAndAllowNonCallbacksIsFalse_ReturnsError) {
382 Pipe pipe;
383 sp<Looper> looper = new Looper(false /*allowNonCallbacks*/);
384 int result = looper->addFd(pipe.receiveFd, 0, 0, NULL, NULL);
385
386 EXPECT_EQ(-1, result)
387 << "addFd should return -1 because arguments were invalid";
388 }
389
TEST_F(LooperTest,RemoveFd_WhenCallbackNotAdded_ReturnsZero)390 TEST_F(LooperTest, RemoveFd_WhenCallbackNotAdded_ReturnsZero) {
391 int result = mLooper->removeFd(1);
392
393 EXPECT_EQ(0, result)
394 << "removeFd should return 0 because FD not registered";
395 }
396
TEST_F(LooperTest,RemoveFd_WhenCallbackAddedThenRemovedTwice_ReturnsOnceFirstTimeAndReturnsZeroSecondTime)397 TEST_F(LooperTest, RemoveFd_WhenCallbackAddedThenRemovedTwice_ReturnsOnceFirstTimeAndReturnsZeroSecondTime) {
398 Pipe pipe;
399 StubCallbackHandler handler(false);
400 handler.setCallback(mLooper, pipe.receiveFd, Looper::EVENT_INPUT);
401
402 // First time.
403 int result = mLooper->removeFd(pipe.receiveFd);
404
405 EXPECT_EQ(1, result)
406 << "removeFd should return 1 first time because FD was registered";
407
408 // Second time.
409 result = mLooper->removeFd(pipe.receiveFd);
410
411 EXPECT_EQ(0, result)
412 << "removeFd should return 0 second time because FD was no longer registered";
413 }
414
TEST_F(LooperTest,PollOnce_WhenCallbackAddedTwice_OnlySecondCallbackShouldBeInvoked)415 TEST_F(LooperTest, PollOnce_WhenCallbackAddedTwice_OnlySecondCallbackShouldBeInvoked) {
416 Pipe pipe;
417 StubCallbackHandler handler1(true);
418 StubCallbackHandler handler2(true);
419
420 handler1.setCallback(mLooper, pipe.receiveFd, Looper::EVENT_INPUT);
421 handler2.setCallback(mLooper, pipe.receiveFd, Looper::EVENT_INPUT); // replace it
422 pipe.writeSignal(); // would cause FD to be considered signalled
423
424 StopWatch stopWatch("pollOnce");
425 int result = mLooper->pollOnce(100);
426 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
427
428 ASSERT_EQ(OK, pipe.readSignal())
429 << "signal should actually have been written";
430 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
431 << "elapsed time should approx. zero because FD was already signalled";
432 EXPECT_EQ(Looper::POLL_CALLBACK, result)
433 << "pollOnce result should be Looper::POLL_CALLBACK because FD was signalled";
434 EXPECT_EQ(0, handler1.callbackCount)
435 << "original handler callback should not be invoked because it was replaced";
436 EXPECT_EQ(1, handler2.callbackCount)
437 << "replacement handler callback should be invoked";
438 }
439
TEST_F(LooperTest,SendMessage_WhenOneMessageIsEnqueue_ShouldInvokeHandlerDuringNextPoll)440 TEST_F(LooperTest, SendMessage_WhenOneMessageIsEnqueue_ShouldInvokeHandlerDuringNextPoll) {
441 sp<StubMessageHandler> handler = new StubMessageHandler();
442 mLooper->sendMessage(handler, Message(MSG_TEST1));
443
444 StopWatch stopWatch("pollOnce");
445 int result = mLooper->pollOnce(100);
446 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
447
448 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
449 << "elapsed time should approx. zero because message was already sent";
450 EXPECT_EQ(Looper::POLL_CALLBACK, result)
451 << "pollOnce result should be Looper::POLL_CALLBACK because message was sent";
452 EXPECT_EQ(size_t(1), handler->messages.size())
453 << "handled message";
454 EXPECT_EQ(MSG_TEST1, handler->messages[0].what)
455 << "handled message";
456 }
457
TEST_F(LooperTest,SendMessage_WhenMultipleMessagesAreEnqueued_ShouldInvokeHandlersInOrderDuringNextPoll)458 TEST_F(LooperTest, SendMessage_WhenMultipleMessagesAreEnqueued_ShouldInvokeHandlersInOrderDuringNextPoll) {
459 sp<StubMessageHandler> handler1 = new StubMessageHandler();
460 sp<StubMessageHandler> handler2 = new StubMessageHandler();
461 mLooper->sendMessage(handler1, Message(MSG_TEST1));
462 mLooper->sendMessage(handler2, Message(MSG_TEST2));
463 mLooper->sendMessage(handler1, Message(MSG_TEST3));
464 mLooper->sendMessage(handler1, Message(MSG_TEST4));
465
466 StopWatch stopWatch("pollOnce");
467 int result = mLooper->pollOnce(1000);
468 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
469
470 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
471 << "elapsed time should approx. zero because message was already sent";
472 EXPECT_EQ(Looper::POLL_CALLBACK, result)
473 << "pollOnce result should be Looper::POLL_CALLBACK because message was sent";
474 EXPECT_EQ(size_t(3), handler1->messages.size())
475 << "handled message";
476 EXPECT_EQ(MSG_TEST1, handler1->messages[0].what)
477 << "handled message";
478 EXPECT_EQ(MSG_TEST3, handler1->messages[1].what)
479 << "handled message";
480 EXPECT_EQ(MSG_TEST4, handler1->messages[2].what)
481 << "handled message";
482 EXPECT_EQ(size_t(1), handler2->messages.size())
483 << "handled message";
484 EXPECT_EQ(MSG_TEST2, handler2->messages[0].what)
485 << "handled message";
486 }
487
TEST_F(LooperTest,SendMessageDelayed_WhenSentToTheFuture_ShouldInvokeHandlerAfterDelayTime)488 TEST_F(LooperTest, SendMessageDelayed_WhenSentToTheFuture_ShouldInvokeHandlerAfterDelayTime) {
489 sp<StubMessageHandler> handler = new StubMessageHandler();
490 mLooper->sendMessageDelayed(ms2ns(100), handler, Message(MSG_TEST1));
491
492 StopWatch stopWatch("pollOnce");
493 int result = mLooper->pollOnce(1000);
494 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
495
496 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
497 << "first poll should end quickly because next message timeout was computed";
498 EXPECT_EQ(Looper::POLL_WAKE, result)
499 << "pollOnce result should be Looper::POLL_WAKE due to wakeup";
500 EXPECT_EQ(size_t(0), handler->messages.size())
501 << "no message handled yet";
502
503 result = mLooper->pollOnce(1000);
504 elapsedMillis = ns2ms(stopWatch.elapsedTime());
505
506 EXPECT_EQ(size_t(1), handler->messages.size())
507 << "handled message";
508 EXPECT_EQ(MSG_TEST1, handler->messages[0].what)
509 << "handled message";
510 EXPECT_NEAR(100, elapsedMillis, TIMING_TOLERANCE_MS)
511 << "second poll should end around the time of the delayed message dispatch";
512 EXPECT_EQ(Looper::POLL_CALLBACK, result)
513 << "pollOnce result should be Looper::POLL_CALLBACK because message was sent";
514
515 result = mLooper->pollOnce(100);
516 elapsedMillis = ns2ms(stopWatch.elapsedTime());
517
518 EXPECT_NEAR(100 + 100, elapsedMillis, TIMING_TOLERANCE_MS)
519 << "third poll should timeout";
520 EXPECT_EQ(Looper::POLL_TIMEOUT, result)
521 << "pollOnce result should be Looper::POLL_TIMEOUT because there were no messages left";
522 }
523
TEST_F(LooperTest,SendMessageDelayed_WhenSentToThePast_ShouldInvokeHandlerDuringNextPoll)524 TEST_F(LooperTest, SendMessageDelayed_WhenSentToThePast_ShouldInvokeHandlerDuringNextPoll) {
525 sp<StubMessageHandler> handler = new StubMessageHandler();
526 mLooper->sendMessageDelayed(ms2ns(-1000), handler, Message(MSG_TEST1));
527
528 StopWatch stopWatch("pollOnce");
529 int result = mLooper->pollOnce(100);
530 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
531
532 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
533 << "elapsed time should approx. zero because message was already sent";
534 EXPECT_EQ(Looper::POLL_CALLBACK, result)
535 << "pollOnce result should be Looper::POLL_CALLBACK because message was sent";
536 EXPECT_EQ(size_t(1), handler->messages.size())
537 << "handled message";
538 EXPECT_EQ(MSG_TEST1, handler->messages[0].what)
539 << "handled message";
540 }
541
TEST_F(LooperTest,SendMessageDelayed_WhenSentToThePresent_ShouldInvokeHandlerDuringNextPoll)542 TEST_F(LooperTest, SendMessageDelayed_WhenSentToThePresent_ShouldInvokeHandlerDuringNextPoll) {
543 sp<StubMessageHandler> handler = new StubMessageHandler();
544 mLooper->sendMessageDelayed(0, handler, Message(MSG_TEST1));
545
546 StopWatch stopWatch("pollOnce");
547 int result = mLooper->pollOnce(100);
548 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
549
550 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
551 << "elapsed time should approx. zero because message was already sent";
552 EXPECT_EQ(Looper::POLL_CALLBACK, result)
553 << "pollOnce result should be Looper::POLL_CALLBACK because message was sent";
554 EXPECT_EQ(size_t(1), handler->messages.size())
555 << "handled message";
556 EXPECT_EQ(MSG_TEST1, handler->messages[0].what)
557 << "handled message";
558 }
559
TEST_F(LooperTest,SendMessageAtTime_WhenSentToTheFuture_ShouldInvokeHandlerAfterDelayTime)560 TEST_F(LooperTest, SendMessageAtTime_WhenSentToTheFuture_ShouldInvokeHandlerAfterDelayTime) {
561 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
562 sp<StubMessageHandler> handler = new StubMessageHandler();
563 mLooper->sendMessageAtTime(now + ms2ns(100), handler, Message(MSG_TEST1));
564
565 StopWatch stopWatch("pollOnce");
566 int result = mLooper->pollOnce(1000);
567 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
568
569 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
570 << "first poll should end quickly because next message timeout was computed";
571 EXPECT_EQ(Looper::POLL_WAKE, result)
572 << "pollOnce result should be Looper::POLL_WAKE due to wakeup";
573 EXPECT_EQ(size_t(0), handler->messages.size())
574 << "no message handled yet";
575
576 result = mLooper->pollOnce(1000);
577 elapsedMillis = ns2ms(stopWatch.elapsedTime());
578
579 EXPECT_EQ(size_t(1), handler->messages.size())
580 << "handled message";
581 EXPECT_EQ(MSG_TEST1, handler->messages[0].what)
582 << "handled message";
583 EXPECT_NEAR(100, elapsedMillis, TIMING_TOLERANCE_MS)
584 << "second poll should end around the time of the delayed message dispatch";
585 EXPECT_EQ(Looper::POLL_CALLBACK, result)
586 << "pollOnce result should be Looper::POLL_CALLBACK because message was sent";
587
588 result = mLooper->pollOnce(100);
589 elapsedMillis = ns2ms(stopWatch.elapsedTime());
590
591 EXPECT_NEAR(100 + 100, elapsedMillis, TIMING_TOLERANCE_MS)
592 << "third poll should timeout";
593 EXPECT_EQ(Looper::POLL_TIMEOUT, result)
594 << "pollOnce result should be Looper::POLL_TIMEOUT because there were no messages left";
595 }
596
TEST_F(LooperTest,SendMessageAtTime_WhenSentToThePast_ShouldInvokeHandlerDuringNextPoll)597 TEST_F(LooperTest, SendMessageAtTime_WhenSentToThePast_ShouldInvokeHandlerDuringNextPoll) {
598 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
599 sp<StubMessageHandler> handler = new StubMessageHandler();
600 mLooper->sendMessageAtTime(now - ms2ns(1000), handler, Message(MSG_TEST1));
601
602 StopWatch stopWatch("pollOnce");
603 int result = mLooper->pollOnce(100);
604 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
605
606 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
607 << "elapsed time should approx. zero because message was already sent";
608 EXPECT_EQ(Looper::POLL_CALLBACK, result)
609 << "pollOnce result should be Looper::POLL_CALLBACK because message was sent";
610 EXPECT_EQ(size_t(1), handler->messages.size())
611 << "handled message";
612 EXPECT_EQ(MSG_TEST1, handler->messages[0].what)
613 << "handled message";
614 }
615
TEST_F(LooperTest,SendMessageAtTime_WhenSentToThePresent_ShouldInvokeHandlerDuringNextPoll)616 TEST_F(LooperTest, SendMessageAtTime_WhenSentToThePresent_ShouldInvokeHandlerDuringNextPoll) {
617 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
618 sp<StubMessageHandler> handler = new StubMessageHandler();
619 mLooper->sendMessageAtTime(now, handler, Message(MSG_TEST1));
620
621 StopWatch stopWatch("pollOnce");
622 int result = mLooper->pollOnce(100);
623 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
624
625 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
626 << "elapsed time should approx. zero because message was already sent";
627 EXPECT_EQ(Looper::POLL_CALLBACK, result)
628 << "pollOnce result should be Looper::POLL_CALLBACK because message was sent";
629 EXPECT_EQ(size_t(1), handler->messages.size())
630 << "handled message";
631 EXPECT_EQ(MSG_TEST1, handler->messages[0].what)
632 << "handled message";
633 }
634
TEST_F(LooperTest,RemoveMessage_WhenRemovingAllMessagesForHandler_ShouldRemoveThoseMessage)635 TEST_F(LooperTest, RemoveMessage_WhenRemovingAllMessagesForHandler_ShouldRemoveThoseMessage) {
636 sp<StubMessageHandler> handler = new StubMessageHandler();
637 mLooper->sendMessage(handler, Message(MSG_TEST1));
638 mLooper->sendMessage(handler, Message(MSG_TEST2));
639 mLooper->sendMessage(handler, Message(MSG_TEST3));
640 mLooper->removeMessages(handler);
641
642 StopWatch stopWatch("pollOnce");
643 int result = mLooper->pollOnce(0);
644 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
645
646 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
647 << "elapsed time should approx. zero because message was sent so looper was awoken";
648 EXPECT_EQ(Looper::POLL_WAKE, result)
649 << "pollOnce result should be Looper::POLL_WAKE because looper was awoken";
650 EXPECT_EQ(size_t(0), handler->messages.size())
651 << "no messages to handle";
652
653 result = mLooper->pollOnce(0);
654
655 EXPECT_EQ(Looper::POLL_TIMEOUT, result)
656 << "pollOnce result should be Looper::POLL_TIMEOUT because there was nothing to do";
657 EXPECT_EQ(size_t(0), handler->messages.size())
658 << "no messages to handle";
659 }
660
TEST_F(LooperTest,RemoveMessage_WhenRemovingSomeMessagesForHandler_ShouldRemoveThoseMessage)661 TEST_F(LooperTest, RemoveMessage_WhenRemovingSomeMessagesForHandler_ShouldRemoveThoseMessage) {
662 sp<StubMessageHandler> handler = new StubMessageHandler();
663 mLooper->sendMessage(handler, Message(MSG_TEST1));
664 mLooper->sendMessage(handler, Message(MSG_TEST2));
665 mLooper->sendMessage(handler, Message(MSG_TEST3));
666 mLooper->sendMessage(handler, Message(MSG_TEST4));
667 mLooper->removeMessages(handler, MSG_TEST3);
668 mLooper->removeMessages(handler, MSG_TEST1);
669
670 StopWatch stopWatch("pollOnce");
671 int result = mLooper->pollOnce(0);
672 int32_t elapsedMillis = ns2ms(stopWatch.elapsedTime());
673
674 EXPECT_NEAR(0, elapsedMillis, TIMING_TOLERANCE_MS)
675 << "elapsed time should approx. zero because message was sent so looper was awoken";
676 EXPECT_EQ(Looper::POLL_CALLBACK, result)
677 << "pollOnce result should be Looper::POLL_CALLBACK because two messages were sent";
678 EXPECT_EQ(size_t(2), handler->messages.size())
679 << "no messages to handle";
680 EXPECT_EQ(MSG_TEST2, handler->messages[0].what)
681 << "handled message";
682 EXPECT_EQ(MSG_TEST4, handler->messages[1].what)
683 << "handled message";
684
685 result = mLooper->pollOnce(0);
686
687 EXPECT_EQ(Looper::POLL_TIMEOUT, result)
688 << "pollOnce result should be Looper::POLL_TIMEOUT because there was nothing to do";
689 EXPECT_EQ(size_t(2), handler->messages.size())
690 << "no more messages to handle";
691 }
692
693 } // namespace android
694