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