1 /******************************************************************************
2 *
3 * Copyright 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 "osi/include/alarm.h"
20
21 #include <base/run_loop.h>
22 #include <gtest/gtest.h>
23 #include <hardware/bluetooth.h>
24
25 #include "common/message_loop_thread.h"
26 #include "osi/include/fixed_queue.h"
27 #include "osi/include/osi.h"
28 #include "osi/include/wakelock.h"
29 #include "osi/semaphore.h"
30
31 using base::Closure;
32 using bluetooth::common::MessageLoopThread;
33
34 static semaphore_t* semaphore;
35 static int cb_counter;
36 static int cb_misordered_counter;
37
38 static const uint64_t EPSILON_MS = 50;
39
msleep(uint64_t ms)40 static void msleep(uint64_t ms) { usleep(ms * 1000); }
41
42 static MessageLoopThread* thread_;
43
get_main_thread()44 bluetooth::common::MessageLoopThread* get_main_thread() { return thread_; }
45
46 extern int64_t TIMER_INTERVAL_FOR_WAKELOCK_IN_MS;
47
48 static bool is_wake_lock_acquired = false;
49
acquire_wake_lock_cb(const char * lock_name)50 static int acquire_wake_lock_cb(const char* lock_name) {
51 is_wake_lock_acquired = true;
52 return BT_STATUS_SUCCESS;
53 }
54
release_wake_lock_cb(const char * lock_name)55 static int release_wake_lock_cb(const char* lock_name) {
56 is_wake_lock_acquired = false;
57 return BT_STATUS_SUCCESS;
58 }
59
60 static bt_os_callouts_t bt_wakelock_callouts = {
61 sizeof(bt_os_callouts_t), acquire_wake_lock_cb, release_wake_lock_cb};
62
63 class AlarmTest : public ::testing::Test {
64 protected:
SetUp()65 void SetUp() override {
66 TIMER_INTERVAL_FOR_WAKELOCK_IN_MS = 500;
67
68 wakelock_set_os_callouts(&bt_wakelock_callouts);
69
70 cb_counter = 0;
71 cb_misordered_counter = 0;
72
73 semaphore = semaphore_new(0);
74 }
75
TearDown()76 void TearDown() override {
77 semaphore_free(semaphore);
78 alarm_cleanup();
79 wakelock_cleanup();
80 wakelock_set_os_callouts(NULL);
81 }
82 };
83
cb(void *)84 static void cb(void* /* data */) {
85 ++cb_counter;
86 semaphore_post(semaphore);
87 }
88
ordered_cb(void * data)89 static void ordered_cb(void* data) {
90 int i = PTR_TO_INT(data);
91 if (i != cb_counter) cb_misordered_counter++;
92 ++cb_counter;
93 semaphore_post(semaphore);
94 }
95
TEST_F(AlarmTest,test_new_free_simple)96 TEST_F(AlarmTest, test_new_free_simple) {
97 alarm_t* alarm = alarm_new("alarm_test.test_new_free_simple");
98 ASSERT_TRUE(alarm != NULL);
99 alarm_free(alarm);
100 }
101
TEST_F(AlarmTest,test_free_null)102 TEST_F(AlarmTest, test_free_null) { alarm_free(NULL); }
103
TEST_F(AlarmTest,test_simple_cancel)104 TEST_F(AlarmTest, test_simple_cancel) {
105 alarm_t* alarm = alarm_new("alarm_test.test_simple_cancel");
106 alarm_cancel(alarm);
107 alarm_free(alarm);
108 }
109
TEST_F(AlarmTest,test_cancel)110 TEST_F(AlarmTest, test_cancel) {
111 alarm_t* alarm = alarm_new("alarm_test.test_cancel");
112 alarm_set(alarm, 10, cb, NULL);
113 alarm_cancel(alarm);
114
115 msleep(10 + EPSILON_MS);
116
117 EXPECT_EQ(cb_counter, 0);
118 EXPECT_FALSE(is_wake_lock_acquired);
119 alarm_free(alarm);
120 }
121
TEST_F(AlarmTest,test_cancel_idempotent)122 TEST_F(AlarmTest, test_cancel_idempotent) {
123 alarm_t* alarm = alarm_new("alarm_test.test_cancel_idempotent");
124 alarm_set(alarm, 10, cb, NULL);
125 alarm_cancel(alarm);
126 alarm_cancel(alarm);
127 alarm_cancel(alarm);
128 alarm_free(alarm);
129 }
130
TEST_F(AlarmTest,test_set_short)131 TEST_F(AlarmTest, test_set_short) {
132 alarm_t* alarm = alarm_new("alarm_test.test_set_short");
133
134 alarm_set(alarm, 10, cb, NULL);
135
136 EXPECT_EQ(cb_counter, 0);
137 EXPECT_TRUE(is_wake_lock_acquired);
138
139 semaphore_wait(semaphore);
140
141 EXPECT_EQ(cb_counter, 1);
142 EXPECT_FALSE(is_wake_lock_acquired);
143
144 alarm_free(alarm);
145 }
146
TEST_F(AlarmTest,test_set_short_periodic)147 TEST_F(AlarmTest, test_set_short_periodic) {
148 alarm_t* alarm = alarm_new_periodic("alarm_test.test_set_short_periodic");
149
150 alarm_set(alarm, 10, cb, NULL);
151
152 EXPECT_EQ(cb_counter, 0);
153 EXPECT_TRUE(is_wake_lock_acquired);
154
155 for (int i = 1; i <= 10; i++) {
156 semaphore_wait(semaphore);
157
158 EXPECT_GE(cb_counter, i);
159 EXPECT_TRUE(is_wake_lock_acquired);
160 }
161 alarm_cancel(alarm);
162 EXPECT_FALSE(is_wake_lock_acquired);
163
164 alarm_free(alarm);
165 }
166
TEST_F(AlarmTest,test_set_zero_periodic)167 TEST_F(AlarmTest, test_set_zero_periodic) {
168 alarm_t* alarm = alarm_new_periodic("alarm_test.test_set_zero_periodic");
169
170 alarm_set(alarm, 0, cb, NULL);
171
172 EXPECT_TRUE(is_wake_lock_acquired);
173
174 for (int i = 1; i <= 10; i++) {
175 semaphore_wait(semaphore);
176
177 EXPECT_GE(cb_counter, i);
178 EXPECT_TRUE(is_wake_lock_acquired);
179 }
180 alarm_cancel(alarm);
181 EXPECT_FALSE(is_wake_lock_acquired);
182
183 alarm_free(alarm);
184 }
185
TEST_F(AlarmTest,test_set_long)186 TEST_F(AlarmTest, test_set_long) {
187 alarm_t* alarm = alarm_new("alarm_test.test_set_long");
188 alarm_set(alarm, TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, NULL);
189
190 EXPECT_EQ(cb_counter, 0);
191 EXPECT_FALSE(is_wake_lock_acquired);
192
193 semaphore_wait(semaphore);
194
195 EXPECT_EQ(cb_counter, 1);
196 EXPECT_FALSE(is_wake_lock_acquired);
197
198 alarm_free(alarm);
199 }
200
TEST_F(AlarmTest,test_set_short_short)201 TEST_F(AlarmTest, test_set_short_short) {
202 alarm_t* alarm[2] = {alarm_new("alarm_test.test_set_short_short_0"),
203 alarm_new("alarm_test.test_set_short_short_1")};
204
205 alarm_set(alarm[0], 10, cb, NULL);
206 alarm_set(alarm[1], 200, cb, NULL);
207
208 EXPECT_EQ(cb_counter, 0);
209 EXPECT_TRUE(is_wake_lock_acquired);
210
211 semaphore_wait(semaphore);
212
213 EXPECT_EQ(cb_counter, 1);
214 EXPECT_TRUE(is_wake_lock_acquired);
215
216 semaphore_wait(semaphore);
217
218 EXPECT_EQ(cb_counter, 2);
219 EXPECT_FALSE(is_wake_lock_acquired);
220
221 alarm_free(alarm[0]);
222 alarm_free(alarm[1]);
223 }
224
TEST_F(AlarmTest,test_set_short_long)225 TEST_F(AlarmTest, test_set_short_long) {
226 alarm_t* alarm[2] = {alarm_new("alarm_test.test_set_short_long_0"),
227 alarm_new("alarm_test.test_set_short_long_1")};
228
229 alarm_set(alarm[0], 10, cb, NULL);
230 alarm_set(alarm[1], 10 + TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb,
231 NULL);
232
233 EXPECT_EQ(cb_counter, 0);
234 EXPECT_TRUE(is_wake_lock_acquired);
235
236 semaphore_wait(semaphore);
237
238 EXPECT_EQ(cb_counter, 1);
239 EXPECT_FALSE(is_wake_lock_acquired);
240
241 semaphore_wait(semaphore);
242
243 EXPECT_EQ(cb_counter, 2);
244 EXPECT_FALSE(is_wake_lock_acquired);
245
246 alarm_free(alarm[0]);
247 alarm_free(alarm[1]);
248 }
249
TEST_F(AlarmTest,test_set_long_long)250 TEST_F(AlarmTest, test_set_long_long) {
251 alarm_t* alarm[2] = {alarm_new("alarm_test.test_set_long_long_0"),
252 alarm_new("alarm_test.test_set_long_long_1")};
253
254 alarm_set(alarm[0], TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, NULL);
255 alarm_set(alarm[1], 2 * (TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS), cb,
256 NULL);
257
258 EXPECT_EQ(cb_counter, 0);
259 EXPECT_FALSE(is_wake_lock_acquired);
260
261 semaphore_wait(semaphore);
262
263 EXPECT_EQ(cb_counter, 1);
264 EXPECT_FALSE(is_wake_lock_acquired);
265
266 semaphore_wait(semaphore);
267
268 EXPECT_EQ(cb_counter, 2);
269 EXPECT_FALSE(is_wake_lock_acquired);
270
271 alarm_free(alarm[0]);
272 alarm_free(alarm[1]);
273 }
274
TEST_F(AlarmTest,test_is_scheduled)275 TEST_F(AlarmTest, test_is_scheduled) {
276 alarm_t* alarm = alarm_new("alarm_test.test_is_scheduled");
277
278 EXPECT_FALSE(alarm_is_scheduled((alarm_t*)NULL));
279 EXPECT_FALSE(alarm_is_scheduled(alarm));
280 alarm_set(alarm, TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, NULL);
281 EXPECT_TRUE(alarm_is_scheduled(alarm));
282
283 EXPECT_EQ(cb_counter, 0);
284 EXPECT_FALSE(is_wake_lock_acquired);
285
286 semaphore_wait(semaphore);
287
288 EXPECT_FALSE(alarm_is_scheduled(alarm));
289 EXPECT_EQ(cb_counter, 1);
290 EXPECT_FALSE(is_wake_lock_acquired);
291
292 alarm_free(alarm);
293 }
294
295 // Test whether the callbacks are invoked in the expected order
TEST_F(AlarmTest,test_callback_ordering)296 TEST_F(AlarmTest, test_callback_ordering) {
297 alarm_t* alarms[100];
298
299 for (int i = 0; i < 100; i++) {
300 const std::string alarm_name =
301 "alarm_test.test_callback_ordering[" + std::to_string(i) + "]";
302 alarms[i] = alarm_new(alarm_name.c_str());
303 }
304
305 for (int i = 0; i < 100; i++) {
306 alarm_set(alarms[i], 100, ordered_cb, INT_TO_PTR(i));
307 }
308
309 for (int i = 1; i <= 100; i++) {
310 semaphore_wait(semaphore);
311 EXPECT_GE(cb_counter, i);
312 }
313 EXPECT_EQ(cb_counter, 100);
314 EXPECT_EQ(cb_misordered_counter, 0);
315
316 for (int i = 0; i < 100; i++) alarm_free(alarms[i]);
317
318 EXPECT_FALSE(is_wake_lock_acquired);
319 }
320
321 // Test whether the callbacks are involed in the expected order on a
322 // message loop.
TEST_F(AlarmTest,test_callback_ordering_on_mloop)323 TEST_F(AlarmTest, test_callback_ordering_on_mloop) {
324 alarm_t* alarms[100];
325
326 // Initialize MesageLoop, and wait till it's initialized.
327 MessageLoopThread message_loop_thread("btu message loop");
328 message_loop_thread.StartUp();
329 if (!message_loop_thread.IsRunning()) {
330 FAIL() << "unable to create btu message loop thread.";
331 }
332 thread_ = &message_loop_thread;
333
334 for (int i = 0; i < 100; i++) {
335 const std::string alarm_name =
336 "alarm_test.test_callback_ordering_on_mloop[" + std::to_string(i) + "]";
337 alarms[i] = alarm_new(alarm_name.c_str());
338 }
339
340 for (int i = 0; i < 100; i++) {
341 alarm_set_on_mloop(alarms[i], 100, ordered_cb, INT_TO_PTR(i));
342 }
343
344 for (int i = 1; i <= 100; i++) {
345 semaphore_wait(semaphore);
346 EXPECT_GE(cb_counter, i);
347 }
348 EXPECT_EQ(cb_counter, 100);
349 EXPECT_EQ(cb_misordered_counter, 0);
350
351 for (int i = 0; i < 100; i++) alarm_free(alarms[i]);
352
353 message_loop_thread.ShutDown();
354 EXPECT_FALSE(is_wake_lock_acquired);
355 }
356
357 // Try to catch any race conditions between the timer callback and |alarm_free|.
TEST_F(AlarmTest,test_callback_free_race)358 TEST_F(AlarmTest, test_callback_free_race) {
359 for (int i = 0; i < 1000; ++i) {
360 const std::string alarm_name =
361 "alarm_test.test_callback_free_race[" + std::to_string(i) + "]";
362 alarm_t* alarm = alarm_new(alarm_name.c_str());
363 alarm_set(alarm, 0, cb, NULL);
364 alarm_free(alarm);
365 }
366 alarm_cleanup();
367 }
368
remove_cb(void * data)369 static void remove_cb(void* data) {
370 alarm_free((alarm_t*)data);
371 semaphore_post(semaphore);
372 }
373
TEST_F(AlarmTest,test_delete_during_callback)374 TEST_F(AlarmTest, test_delete_during_callback) {
375 for (int i = 0; i < 1000; ++i) {
376 alarm_t* alarm = alarm_new("alarm_test.test_delete_during_callback");
377 alarm_set(alarm, 0, remove_cb, alarm);
378 semaphore_wait(semaphore);
379 }
380 alarm_cleanup();
381 }
382