1 /******************************************************************************
2 *
3 * Copyright (C) 2014 Google, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 #include <gtest/gtest.h>
20
21 #include "AlarmTestHarness.h"
22
23 extern "C" {
24 #include "osi/include/alarm.h"
25 #include "osi/include/fixed_queue.h"
26 #include "osi/include/osi.h"
27 #include "osi/include/semaphore.h"
28 #include "osi/include/thread.h"
29 }
30
31 static semaphore_t *semaphore;
32 static int cb_counter;
33 static int cb_misordered_counter;
34
35 static const uint64_t EPSILON_MS = 5;
36
msleep(uint64_t ms)37 static void msleep(uint64_t ms) {
38 usleep(ms * 1000);
39 }
40
41 class AlarmTest : public AlarmTestHarness {
42 protected:
SetUp()43 virtual void SetUp() {
44 AlarmTestHarness::SetUp();
45 cb_counter = 0;
46 cb_misordered_counter = 0;
47
48 semaphore = semaphore_new(0);
49 }
50
TearDown()51 virtual void TearDown() {
52 semaphore_free(semaphore);
53 AlarmTestHarness::TearDown();
54 }
55 };
56
cb(UNUSED_ATTR void * data)57 static void cb(UNUSED_ATTR void *data) {
58 ++cb_counter;
59 semaphore_post(semaphore);
60 }
61
ordered_cb(void * data)62 static void ordered_cb(void *data) {
63 int i = PTR_TO_INT(data);
64 if (i != cb_counter)
65 cb_misordered_counter++;
66 ++cb_counter;
67 semaphore_post(semaphore);
68 }
69
TEST_F(AlarmTest,test_new_free_simple)70 TEST_F(AlarmTest, test_new_free_simple) {
71 alarm_t *alarm = alarm_new("alarm_test.test_new_free_simple");
72 ASSERT_TRUE(alarm != NULL);
73 alarm_free(alarm);
74 }
75
TEST_F(AlarmTest,test_free_null)76 TEST_F(AlarmTest, test_free_null) {
77 alarm_free(NULL);
78 }
79
TEST_F(AlarmTest,test_simple_cancel)80 TEST_F(AlarmTest, test_simple_cancel) {
81 alarm_t *alarm = alarm_new("alarm_test.test_simple_cancel");
82 alarm_cancel(alarm);
83 alarm_free(alarm);
84 }
85
TEST_F(AlarmTest,test_cancel)86 TEST_F(AlarmTest, test_cancel) {
87 alarm_t *alarm = alarm_new("alarm_test.test_cancel");
88 alarm_set(alarm, 10, cb, NULL);
89 alarm_cancel(alarm);
90
91 msleep(10 + EPSILON_MS);
92
93 EXPECT_EQ(cb_counter, 0);
94 EXPECT_FALSE(WakeLockHeld());
95 alarm_free(alarm);
96 }
97
TEST_F(AlarmTest,test_cancel_idempotent)98 TEST_F(AlarmTest, test_cancel_idempotent) {
99 alarm_t *alarm = alarm_new("alarm_test.test_cancel_idempotent");
100 alarm_set(alarm, 10, cb, NULL);
101 alarm_cancel(alarm);
102 alarm_cancel(alarm);
103 alarm_cancel(alarm);
104 alarm_free(alarm);
105 }
106
TEST_F(AlarmTest,test_set_short)107 TEST_F(AlarmTest, test_set_short) {
108 alarm_t *alarm = alarm_new("alarm_test.test_set_short");
109
110 alarm_set(alarm, 10, cb, NULL);
111
112 EXPECT_EQ(cb_counter, 0);
113 EXPECT_TRUE(WakeLockHeld());
114
115 semaphore_wait(semaphore);
116
117 EXPECT_EQ(cb_counter, 1);
118 EXPECT_FALSE(WakeLockHeld());
119
120 alarm_free(alarm);
121 }
122
TEST_F(AlarmTest,test_set_short_periodic)123 TEST_F(AlarmTest, test_set_short_periodic) {
124 alarm_t *alarm = alarm_new_periodic("alarm_test.test_set_short_periodic");
125
126 alarm_set(alarm, 10, cb, NULL);
127
128 EXPECT_EQ(cb_counter, 0);
129 EXPECT_TRUE(WakeLockHeld());
130
131 for (int i = 1; i <= 10; i++) {
132 semaphore_wait(semaphore);
133
134 EXPECT_GE(cb_counter, i);
135 EXPECT_TRUE(WakeLockHeld());
136 }
137 alarm_cancel(alarm);
138 EXPECT_FALSE(WakeLockHeld());
139
140 alarm_free(alarm);
141 }
142
TEST_F(AlarmTest,test_set_zero_periodic)143 TEST_F(AlarmTest, test_set_zero_periodic) {
144 alarm_t *alarm = alarm_new_periodic("alarm_test.test_set_zero_periodic");
145
146 alarm_set(alarm, 0, cb, NULL);
147
148 EXPECT_TRUE(WakeLockHeld());
149
150 for (int i = 1; i <= 10; i++) {
151 semaphore_wait(semaphore);
152
153 EXPECT_GE(cb_counter, i);
154 EXPECT_TRUE(WakeLockHeld());
155 }
156 alarm_cancel(alarm);
157 EXPECT_FALSE(WakeLockHeld());
158
159 alarm_free(alarm);
160 }
161
TEST_F(AlarmTest,test_set_long)162 TEST_F(AlarmTest, test_set_long) {
163 alarm_t *alarm = alarm_new("alarm_test.test_set_long");
164 alarm_set(alarm, TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, NULL);
165
166 EXPECT_EQ(cb_counter, 0);
167 EXPECT_FALSE(WakeLockHeld());
168
169 semaphore_wait(semaphore);
170
171 EXPECT_EQ(cb_counter, 1);
172 EXPECT_FALSE(WakeLockHeld());
173
174 alarm_free(alarm);
175 }
176
TEST_F(AlarmTest,test_set_short_short)177 TEST_F(AlarmTest, test_set_short_short) {
178 alarm_t *alarm[2] = {
179 alarm_new("alarm_test.test_set_short_short_0"),
180 alarm_new("alarm_test.test_set_short_short_1")
181 };
182
183 alarm_set(alarm[0], 10, cb, NULL);
184 alarm_set(alarm[1], 20, cb, NULL);
185
186 EXPECT_EQ(cb_counter, 0);
187 EXPECT_TRUE(WakeLockHeld());
188
189 semaphore_wait(semaphore);
190
191 EXPECT_EQ(cb_counter, 1);
192 EXPECT_TRUE(WakeLockHeld());
193
194 semaphore_wait(semaphore);
195
196 EXPECT_EQ(cb_counter, 2);
197 EXPECT_FALSE(WakeLockHeld());
198
199 alarm_free(alarm[0]);
200 alarm_free(alarm[1]);
201 }
202
TEST_F(AlarmTest,test_set_short_long)203 TEST_F(AlarmTest, test_set_short_long) {
204 alarm_t *alarm[2] = {
205 alarm_new("alarm_test.test_set_short_long_0"),
206 alarm_new("alarm_test.test_set_short_long_1")
207 };
208
209 alarm_set(alarm[0], 10, cb, NULL);
210 alarm_set(alarm[1], 10 + TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, NULL);
211
212 EXPECT_EQ(cb_counter, 0);
213 EXPECT_TRUE(WakeLockHeld());
214
215 semaphore_wait(semaphore);
216
217 EXPECT_EQ(cb_counter, 1);
218 EXPECT_FALSE(WakeLockHeld());
219
220 semaphore_wait(semaphore);
221
222 EXPECT_EQ(cb_counter, 2);
223 EXPECT_FALSE(WakeLockHeld());
224
225 alarm_free(alarm[0]);
226 alarm_free(alarm[1]);
227 }
228
TEST_F(AlarmTest,test_set_long_long)229 TEST_F(AlarmTest, test_set_long_long) {
230 alarm_t *alarm[2] = {
231 alarm_new("alarm_test.test_set_long_long_0"),
232 alarm_new("alarm_test.test_set_long_long_1")
233 };
234
235 alarm_set(alarm[0], TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, NULL);
236 alarm_set(alarm[1], 2 * (TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS), cb, NULL);
237
238 EXPECT_EQ(cb_counter, 0);
239 EXPECT_FALSE(WakeLockHeld());
240
241 semaphore_wait(semaphore);
242
243 EXPECT_EQ(cb_counter, 1);
244 EXPECT_FALSE(WakeLockHeld());
245
246 semaphore_wait(semaphore);
247
248 EXPECT_EQ(cb_counter, 2);
249 EXPECT_FALSE(WakeLockHeld());
250
251 alarm_free(alarm[0]);
252 alarm_free(alarm[1]);
253 }
254
TEST_F(AlarmTest,test_is_scheduled)255 TEST_F(AlarmTest, test_is_scheduled) {
256 alarm_t *alarm = alarm_new("alarm_test.test_is_scheduled");
257
258 EXPECT_FALSE(alarm_is_scheduled((alarm_t *)NULL));
259 EXPECT_FALSE(alarm_is_scheduled(alarm));
260 alarm_set(alarm, TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, NULL);
261 EXPECT_TRUE(alarm_is_scheduled(alarm));
262
263 EXPECT_EQ(cb_counter, 0);
264 EXPECT_FALSE(WakeLockHeld());
265
266 semaphore_wait(semaphore);
267
268 EXPECT_FALSE(alarm_is_scheduled(alarm));
269 EXPECT_EQ(cb_counter, 1);
270 EXPECT_FALSE(WakeLockHeld());
271
272 alarm_free(alarm);
273 }
274
275 // Test whether the callbacks are invoked in the expected order
TEST_F(AlarmTest,test_callback_ordering)276 TEST_F(AlarmTest, test_callback_ordering) {
277 alarm_t *alarms[100];
278
279 for (int i = 0; i < 100; i++) {
280 const std::string alarm_name = "alarm_test.test_callback_ordering[" +
281 std::to_string(i) + "]";
282 alarms[i] = alarm_new(alarm_name.c_str());
283 }
284
285 for (int i = 0; i < 100; i++) {
286 alarm_set(alarms[i], 100, ordered_cb, INT_TO_PTR(i));
287 }
288
289 for (int i = 1; i <= 100; i++) {
290 semaphore_wait(semaphore);
291 EXPECT_GE(cb_counter, i);
292 }
293 EXPECT_EQ(cb_counter, 100);
294 EXPECT_EQ(cb_misordered_counter, 0);
295
296 for (int i = 0; i < 100; i++)
297 alarm_free(alarms[i]);
298
299 EXPECT_FALSE(WakeLockHeld());
300 }
301
302 // Test whether the callbacks are involed in the expected order on a
303 // separate queue.
TEST_F(AlarmTest,test_callback_ordering_on_queue)304 TEST_F(AlarmTest, test_callback_ordering_on_queue) {
305 alarm_t *alarms[100];
306 fixed_queue_t *queue = fixed_queue_new(SIZE_MAX);
307 thread_t *thread = thread_new("timers.test_callback_ordering_on_queue.thread");
308
309 alarm_register_processing_queue(queue, thread);
310
311 for (int i = 0; i < 100; i++) {
312 const std::string alarm_name =
313 "alarm_test.test_callback_ordering_on_queue[" +
314 std::to_string(i) + "]";
315 alarms[i] = alarm_new(alarm_name.c_str());
316 }
317
318 for (int i = 0; i < 100; i++) {
319 alarm_set_on_queue(alarms[i], 100, ordered_cb, INT_TO_PTR(i), queue);
320 }
321
322 for (int i = 1; i <= 100; i++) {
323 semaphore_wait(semaphore);
324 EXPECT_GE(cb_counter, i);
325 }
326 EXPECT_EQ(cb_counter, 100);
327 EXPECT_EQ(cb_misordered_counter, 0);
328
329 for (int i = 0; i < 100; i++)
330 alarm_free(alarms[i]);
331
332 EXPECT_FALSE(WakeLockHeld());
333
334 alarm_unregister_processing_queue(queue);
335 fixed_queue_free(queue, NULL);
336 thread_free(thread);
337 }
338
339 // Test whether unregistering a processing queue cancels all timers using
340 // that queue.
TEST_F(AlarmTest,test_unregister_processing_queue)341 TEST_F(AlarmTest, test_unregister_processing_queue) {
342 alarm_t *alarms[100];
343 fixed_queue_t *queue = fixed_queue_new(SIZE_MAX);
344 thread_t *thread =
345 thread_new("timers.test_unregister_processing_queue.thread");
346
347 alarm_register_processing_queue(queue, thread);
348
349 for (int i = 0; i < 100; i++) {
350 const std::string alarm_name =
351 "alarm_test.test_unregister_processing_queue[" +
352 std::to_string(i) + "]";
353 alarms[i] = alarm_new(alarm_name.c_str());
354 }
355
356 // Schedule half of the timers to expire soon, and the rest far in the future
357 for (int i = 0; i < 50; i++) {
358 alarm_set_on_queue(alarms[i], 100, ordered_cb, INT_TO_PTR(i), queue);
359 }
360 for (int i = 50; i < 100; i++) {
361 alarm_set_on_queue(alarms[i], 1000 * 1000, ordered_cb, INT_TO_PTR(i), queue);
362 }
363
364 // Wait until half of the timers have expired
365 for (int i = 1; i <= 50; i++) {
366 semaphore_wait(semaphore);
367 EXPECT_GE(cb_counter, i);
368 }
369 EXPECT_EQ(cb_counter, 50);
370 EXPECT_EQ(cb_misordered_counter, 0);
371
372 // Test that only the expired timers are not scheduled
373 for (int i = 0; i < 50; i++) {
374 EXPECT_FALSE(alarm_is_scheduled(alarms[i]));
375 }
376 for (int i = 50; i < 100; i++) {
377 EXPECT_TRUE(alarm_is_scheduled(alarms[i]));
378 }
379
380 alarm_unregister_processing_queue(queue);
381
382 // Test that none of the timers are scheduled
383 for (int i = 0; i < 100; i++) {
384 EXPECT_FALSE(alarm_is_scheduled(alarms[i]));
385 }
386
387 for (int i = 0; i < 100; i++) {
388 alarm_free(alarms[i]);
389 }
390
391 EXPECT_FALSE(WakeLockHeld());
392
393 fixed_queue_free(queue, NULL);
394 thread_free(thread);
395 }
396
397 // Test whether unregistering a processing queue cancels all periodic timers
398 // using that queue.
TEST_F(AlarmTest,test_periodic_unregister_processing_queue)399 TEST_F(AlarmTest, test_periodic_unregister_processing_queue) {
400 alarm_t *alarms[5];
401 fixed_queue_t *queue = fixed_queue_new(SIZE_MAX);
402 thread_t *thread =
403 thread_new("timers.test_periodic_unregister_processing_queue.thread");
404
405 alarm_register_processing_queue(queue, thread);
406
407 for (int i = 0; i < 5; i++) {
408 const std::string alarm_name =
409 "alarm_test.test_periodic_unregister_processing_queue[" +
410 std::to_string(i) + "]";
411 alarms[i] = alarm_new_periodic(alarm_name.c_str());
412 }
413
414 // Schedule each of the timers with different period
415 for (int i = 0; i < 5; i++) {
416 alarm_set_on_queue(alarms[i], 20 + i, cb, INT_TO_PTR(i), queue);
417 }
418 EXPECT_TRUE(WakeLockHeld());
419
420 for (int i = 1; i <= 20; i++) {
421 semaphore_wait(semaphore);
422
423 EXPECT_GE(cb_counter, i);
424 EXPECT_TRUE(WakeLockHeld());
425 }
426
427 // Test that all timers are still scheduled
428 for (int i = 0; i < 5; i++) {
429 EXPECT_TRUE(alarm_is_scheduled(alarms[i]));
430 }
431
432 alarm_unregister_processing_queue(queue);
433
434 int saved_cb_counter = cb_counter;
435
436 // Test that none of the timers are scheduled
437 for (int i = 0; i < 5; i++) {
438 EXPECT_FALSE(alarm_is_scheduled(alarms[i]));
439 }
440
441 // Sleep for 500ms and test again that the cb_counter hasn't been modified
442 usleep(500 * 1000);
443 EXPECT_TRUE(cb_counter == saved_cb_counter);
444
445 for (int i = 0; i < 5; i++) {
446 alarm_free(alarms[i]);
447 }
448
449 EXPECT_FALSE(WakeLockHeld());
450
451 fixed_queue_free(queue, NULL);
452 thread_free(thread);
453 }
454
455 // Try to catch any race conditions between the timer callback and |alarm_free|.
TEST_F(AlarmTest,test_callback_free_race)456 TEST_F(AlarmTest, test_callback_free_race) {
457 for (int i = 0; i < 1000; ++i) {
458 const std::string alarm_name = "alarm_test.test_callback_free_race[" +
459 std::to_string(i) + "]";
460 alarm_t *alarm = alarm_new(alarm_name.c_str());
461 alarm_set(alarm, 0, cb, NULL);
462 alarm_free(alarm);
463 }
464 alarm_cleanup();
465 }
466