alarm_manager_unittest.cc 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497
  1. // Copyright 2017 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. #include "chromecast/base/alarm_manager.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/test/simple_test_clock.h"
  9. #include "base/test/task_environment.h"
  10. #include "base/threading/thread_task_runner_handle.h"
  11. #include "base/time/clock.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. namespace chromecast {
  14. class AlarmManagerTest : public ::testing::Test {
  15. protected:
  16. class WallClockDependantTask {
  17. public:
  18. WallClockDependantTask() : fired_(false), weak_factory_(this) {}
  19. base::WeakPtr<WallClockDependantTask> GetWeakPtr() {
  20. return weak_factory_.GetWeakPtr();
  21. }
  22. void OnAlarmFire() { fired_ = true; }
  23. bool fired_;
  24. base::WeakPtrFactory<WallClockDependantTask> weak_factory_;
  25. };
  26. base::test::SingleThreadTaskEnvironment task_environment_{
  27. base::test::TaskEnvironment::TimeSource::MOCK_TIME};
  28. };
  29. TEST_F(AlarmManagerTest, AlarmNotFire) {
  30. WallClockDependantTask task;
  31. ASSERT_FALSE(task.fired_);
  32. // Create the AlarmManager.
  33. base::Time now = base::Time::Now();
  34. std::unique_ptr<base::SimpleTestClock> test_clock =
  35. std::make_unique<base::SimpleTestClock>();
  36. test_clock->SetNow(now);
  37. base::SimpleTestClock* clock = test_clock.get();
  38. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  39. clock, base::ThreadTaskRunnerHandle::Get());
  40. base::Time alarm_time = now + base::Minutes(10);
  41. std::unique_ptr<AlarmHandle> handle(manager->PostAlarmTask(
  42. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task.GetWeakPtr()),
  43. alarm_time));
  44. task_environment_.FastForwardBy(base::Minutes(9));
  45. clock->Advance(base::Minutes(9));
  46. task_environment_.RunUntilIdle();
  47. ASSERT_FALSE(task.fired_);
  48. }
  49. TEST_F(AlarmManagerTest, AlarmFire) {
  50. WallClockDependantTask task;
  51. ASSERT_FALSE(task.fired_);
  52. // Create the AlarmManager.
  53. base::Time now = base::Time::Now();
  54. std::unique_ptr<base::SimpleTestClock> test_clock =
  55. std::make_unique<base::SimpleTestClock>();
  56. test_clock->SetNow(now);
  57. base::SimpleTestClock* clock = test_clock.get();
  58. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  59. clock, base::ThreadTaskRunnerHandle::Get());
  60. // Add an alarm.
  61. base::Time alarm_time = now + base::Minutes(10);
  62. std::unique_ptr<AlarmHandle> handle(manager->PostAlarmTask(
  63. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task.GetWeakPtr()),
  64. alarm_time));
  65. clock->Advance(base::Minutes(10));
  66. task_environment_.FastForwardBy(base::Minutes(10));
  67. task_environment_.RunUntilIdle();
  68. ASSERT_TRUE(task.fired_);
  69. // Fires only once.
  70. task.fired_ = false;
  71. clock->Advance(base::Minutes(10));
  72. task_environment_.FastForwardBy(base::Minutes(10));
  73. task_environment_.RunUntilIdle();
  74. ASSERT_FALSE(task.fired_);
  75. }
  76. TEST_F(AlarmManagerTest, AlarmPast) {
  77. WallClockDependantTask task;
  78. ASSERT_FALSE(task.fired_);
  79. // Create the AlarmManager.
  80. base::Time now = base::Time::Now();
  81. std::unique_ptr<base::SimpleTestClock> test_clock =
  82. std::make_unique<base::SimpleTestClock>();
  83. test_clock->SetNow(now);
  84. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  85. test_clock.get(), base::ThreadTaskRunnerHandle::Get());
  86. // Add an alarm in the past. Should fire right away.
  87. base::Time alarm_time = base::Time::Now() - base::Minutes(10);
  88. std::unique_ptr<AlarmHandle> handle(manager->PostAlarmTask(
  89. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task.GetWeakPtr()),
  90. alarm_time));
  91. task_environment_.FastForwardBy(base::Seconds(10));
  92. task_environment_.RunUntilIdle();
  93. ASSERT_TRUE(task.fired_);
  94. }
  95. TEST_F(AlarmManagerTest, AlarmTimeJump) {
  96. WallClockDependantTask task;
  97. ASSERT_FALSE(task.fired_);
  98. // Create the AlarmManager.
  99. base::Time now = base::Time::Now();
  100. std::unique_ptr<base::SimpleTestClock> test_clock =
  101. std::make_unique<base::SimpleTestClock>();
  102. test_clock->SetNow(now);
  103. base::SimpleTestClock* clock = test_clock.get();
  104. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  105. clock, base::ThreadTaskRunnerHandle::Get());
  106. // Add an alarm. The time jumps to the future.
  107. base::Time alarm_time = now + base::Minutes(10);
  108. std::unique_ptr<AlarmHandle> handle(manager->PostAlarmTask(
  109. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task.GetWeakPtr()),
  110. alarm_time));
  111. clock->Advance(base::Minutes(10));
  112. task_environment_.FastForwardBy(base::Minutes(1));
  113. task_environment_.RunUntilIdle();
  114. ASSERT_TRUE(task.fired_);
  115. }
  116. TEST_F(AlarmManagerTest, AlarmJumpFuture) {
  117. WallClockDependantTask task;
  118. ASSERT_FALSE(task.fired_);
  119. // Create the AlarmManager.
  120. base::Time now = base::Time::Now();
  121. std::unique_ptr<base::SimpleTestClock> test_clock =
  122. std::make_unique<base::SimpleTestClock>();
  123. test_clock->SetNow(now);
  124. base::SimpleTestClock* clock = test_clock.get();
  125. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  126. clock, base::ThreadTaskRunnerHandle::Get());
  127. // Add an alarm. The time jumps far into the future.
  128. base::Time alarm_time = now + base::Minutes(10);
  129. std::unique_ptr<AlarmHandle> handle(manager->PostAlarmTask(
  130. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task.GetWeakPtr()),
  131. alarm_time));
  132. clock->Advance(base::Minutes(60));
  133. task_environment_.FastForwardBy(base::Minutes(1));
  134. task_environment_.RunUntilIdle();
  135. ASSERT_TRUE(task.fired_);
  136. }
  137. TEST_F(AlarmManagerTest, AlarmMultiple) {
  138. WallClockDependantTask task1;
  139. WallClockDependantTask task2;
  140. ASSERT_FALSE(task1.fired_);
  141. ASSERT_FALSE(task2.fired_);
  142. // Create the AlarmManager.
  143. base::Time now = base::Time::Now();
  144. std::unique_ptr<base::SimpleTestClock> test_clock =
  145. std::make_unique<base::SimpleTestClock>();
  146. test_clock->SetNow(now);
  147. base::SimpleTestClock* clock = test_clock.get();
  148. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  149. clock, base::ThreadTaskRunnerHandle::Get());
  150. // Add first task.
  151. base::Time alarm_time = now + base::Minutes(10);
  152. std::unique_ptr<AlarmHandle> handle1(manager->PostAlarmTask(
  153. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task1.GetWeakPtr()),
  154. alarm_time));
  155. // Add second task.
  156. alarm_time = now + base::Minutes(12);
  157. std::unique_ptr<AlarmHandle> handle2(manager->PostAlarmTask(
  158. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task2.GetWeakPtr()),
  159. alarm_time));
  160. // First task should fire.
  161. clock->Advance(base::Minutes(10));
  162. task_environment_.FastForwardBy(base::Minutes(1));
  163. task_environment_.RunUntilIdle();
  164. ASSERT_TRUE(task1.fired_);
  165. ASSERT_FALSE(task2.fired_);
  166. // Reset state;
  167. task1.fired_ = false;
  168. task2.fired_ = false;
  169. // Second task should fire.
  170. clock->Advance(base::Minutes(2));
  171. task_environment_.FastForwardBy(base::Minutes(1));
  172. task_environment_.RunUntilIdle();
  173. ASSERT_FALSE(task1.fired_);
  174. ASSERT_TRUE(task2.fired_);
  175. }
  176. TEST_F(AlarmManagerTest, AlarmMultipleReverseOrder) {
  177. WallClockDependantTask task1;
  178. WallClockDependantTask task2;
  179. ASSERT_FALSE(task1.fired_);
  180. ASSERT_FALSE(task2.fired_);
  181. // Create the AlarmManager.
  182. base::Time now = base::Time::Now();
  183. std::unique_ptr<base::SimpleTestClock> test_clock =
  184. std::make_unique<base::SimpleTestClock>();
  185. test_clock->SetNow(now);
  186. base::SimpleTestClock* clock = test_clock.get();
  187. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  188. clock, base::ThreadTaskRunnerHandle::Get());
  189. // Add first task.
  190. base::Time alarm_time = now + base::Minutes(12);
  191. std::unique_ptr<AlarmHandle> handle1(manager->PostAlarmTask(
  192. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task1.GetWeakPtr()),
  193. alarm_time));
  194. // Add second task.
  195. alarm_time = now + base::Minutes(10);
  196. std::unique_ptr<AlarmHandle> handle2(manager->PostAlarmTask(
  197. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task2.GetWeakPtr()),
  198. alarm_time));
  199. // Second task should fire.
  200. clock->Advance(base::Minutes(10));
  201. task_environment_.FastForwardBy(base::Minutes(1));
  202. task_environment_.RunUntilIdle();
  203. ASSERT_FALSE(task1.fired_);
  204. ASSERT_TRUE(task2.fired_);
  205. // Reset state;
  206. task1.fired_ = false;
  207. task2.fired_ = false;
  208. // First task should fire.
  209. clock->Advance(base::Minutes(2));
  210. task_environment_.FastForwardBy(base::Minutes(1));
  211. task_environment_.RunUntilIdle();
  212. ASSERT_TRUE(task1.fired_);
  213. ASSERT_FALSE(task2.fired_);
  214. }
  215. TEST_F(AlarmManagerTest, AlarmMultipleSameTime) {
  216. WallClockDependantTask task1;
  217. WallClockDependantTask task2;
  218. WallClockDependantTask task3;
  219. ASSERT_FALSE(task1.fired_);
  220. ASSERT_FALSE(task2.fired_);
  221. ASSERT_FALSE(task3.fired_);
  222. // Create the AlarmManager.
  223. base::Time now = base::Time::Now();
  224. std::unique_ptr<base::SimpleTestClock> test_clock =
  225. std::make_unique<base::SimpleTestClock>();
  226. test_clock->SetNow(now);
  227. base::SimpleTestClock* clock = test_clock.get();
  228. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  229. clock, base::ThreadTaskRunnerHandle::Get());
  230. // Add first task.
  231. base::Time alarm_time = now + base::Minutes(12);
  232. std::unique_ptr<AlarmHandle> handle1(manager->PostAlarmTask(
  233. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task1.GetWeakPtr()),
  234. alarm_time));
  235. // Add second task.
  236. alarm_time = now + base::Minutes(16);
  237. std::unique_ptr<AlarmHandle> handle2(manager->PostAlarmTask(
  238. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task2.GetWeakPtr()),
  239. alarm_time));
  240. // Add third task.
  241. alarm_time = now + base::Minutes(12);
  242. std::unique_ptr<AlarmHandle> handle3(manager->PostAlarmTask(
  243. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task3.GetWeakPtr()),
  244. alarm_time));
  245. // First and third task should fire.
  246. clock->Advance(base::Minutes(12));
  247. task_environment_.FastForwardBy(base::Minutes(1));
  248. task_environment_.RunUntilIdle();
  249. ASSERT_TRUE(task1.fired_);
  250. ASSERT_FALSE(task2.fired_);
  251. ASSERT_TRUE(task3.fired_);
  252. }
  253. TEST_F(AlarmManagerTest, AlarmMultipleShuffle) {
  254. WallClockDependantTask task1;
  255. WallClockDependantTask task2;
  256. WallClockDependantTask task3;
  257. ASSERT_FALSE(task1.fired_);
  258. ASSERT_FALSE(task2.fired_);
  259. ASSERT_FALSE(task3.fired_);
  260. // Create the AlarmManager.
  261. base::Time now = base::Time::Now();
  262. std::unique_ptr<base::SimpleTestClock> test_clock =
  263. std::make_unique<base::SimpleTestClock>();
  264. test_clock->SetNow(now);
  265. base::SimpleTestClock* clock = test_clock.get();
  266. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  267. clock, base::ThreadTaskRunnerHandle::Get());
  268. // Add first task.
  269. base::Time alarm_time = now + base::Minutes(15);
  270. std::unique_ptr<AlarmHandle> handle1(manager->PostAlarmTask(
  271. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task1.GetWeakPtr()),
  272. alarm_time));
  273. // Add second task.
  274. alarm_time = now + base::Minutes(16);
  275. std::unique_ptr<AlarmHandle> handle2(manager->PostAlarmTask(
  276. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task2.GetWeakPtr()),
  277. alarm_time));
  278. // Add third task.
  279. alarm_time = now + base::Minutes(11);
  280. std::unique_ptr<AlarmHandle> handle3(manager->PostAlarmTask(
  281. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task3.GetWeakPtr()),
  282. alarm_time));
  283. // Third task should fire.
  284. clock->Advance(base::Minutes(12));
  285. task_environment_.FastForwardBy(base::Minutes(1));
  286. task_environment_.RunUntilIdle();
  287. ASSERT_FALSE(task1.fired_);
  288. ASSERT_FALSE(task2.fired_);
  289. ASSERT_TRUE(task3.fired_);
  290. clock->Advance(base::Minutes(3));
  291. task_environment_.FastForwardBy(base::Minutes(1));
  292. task_environment_.RunUntilIdle();
  293. ASSERT_TRUE(task1.fired_);
  294. ASSERT_FALSE(task2.fired_);
  295. ASSERT_TRUE(task3.fired_);
  296. }
  297. TEST_F(AlarmManagerTest, AlarmTwice) {
  298. WallClockDependantTask task1;
  299. WallClockDependantTask task2;
  300. ASSERT_FALSE(task1.fired_);
  301. ASSERT_FALSE(task2.fired_);
  302. // Create the AlarmManager.
  303. base::Time now = base::Time::Now();
  304. std::unique_ptr<base::SimpleTestClock> test_clock =
  305. std::make_unique<base::SimpleTestClock>();
  306. test_clock->SetNow(now);
  307. base::SimpleTestClock* clock = test_clock.get();
  308. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  309. clock, base::ThreadTaskRunnerHandle::Get());
  310. // Add first task.
  311. base::Time alarm_time = now + base::Minutes(15);
  312. std::unique_ptr<AlarmHandle> handle1(manager->PostAlarmTask(
  313. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task1.GetWeakPtr()),
  314. alarm_time));
  315. // Add it again with less time.
  316. alarm_time = now + base::Minutes(1);
  317. std::unique_ptr<AlarmHandle> handle2(manager->PostAlarmTask(
  318. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task1.GetWeakPtr()),
  319. alarm_time));
  320. // Add second task.
  321. alarm_time = now + base::Minutes(16);
  322. std::unique_ptr<AlarmHandle> handle3(manager->PostAlarmTask(
  323. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task2.GetWeakPtr()),
  324. alarm_time));
  325. // First task should fire.
  326. clock->Advance(base::Minutes(1));
  327. task_environment_.FastForwardBy(base::Minutes(1));
  328. task_environment_.RunUntilIdle();
  329. ASSERT_TRUE(task1.fired_);
  330. ASSERT_FALSE(task2.fired_);
  331. task1.fired_ = false;
  332. task2.fired_ = false;
  333. // First task should fire again because it was added twice.
  334. clock->Advance(base::Minutes(14));
  335. task_environment_.FastForwardBy(base::Minutes(1));
  336. task_environment_.RunUntilIdle();
  337. ASSERT_TRUE(task1.fired_);
  338. ASSERT_FALSE(task2.fired_);
  339. }
  340. TEST_F(AlarmManagerTest, AlarmCancel) {
  341. std::unique_ptr<WallClockDependantTask> task1 =
  342. std::make_unique<WallClockDependantTask>();
  343. std::unique_ptr<WallClockDependantTask> task2 =
  344. std::make_unique<WallClockDependantTask>();
  345. std::unique_ptr<WallClockDependantTask> task3 =
  346. std::make_unique<WallClockDependantTask>();
  347. ASSERT_FALSE(task1->fired_);
  348. ASSERT_FALSE(task2->fired_);
  349. ASSERT_FALSE(task3->fired_);
  350. // Create the AlarmManager.
  351. base::Time now = base::Time::Now();
  352. std::unique_ptr<base::SimpleTestClock> test_clock =
  353. std::make_unique<base::SimpleTestClock>();
  354. test_clock->SetNow(now);
  355. base::SimpleTestClock* clock = test_clock.get();
  356. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  357. clock, base::ThreadTaskRunnerHandle::Get());
  358. // Add first task.
  359. base::Time alarm_time = now + base::Minutes(12);
  360. std::unique_ptr<AlarmHandle> handle1(manager->PostAlarmTask(
  361. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task1->GetWeakPtr()),
  362. alarm_time));
  363. // Add second task.
  364. alarm_time = now + base::Minutes(16);
  365. std::unique_ptr<AlarmHandle> handle2(manager->PostAlarmTask(
  366. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task2->GetWeakPtr()),
  367. alarm_time));
  368. // Add third task.
  369. alarm_time = now + base::Minutes(12);
  370. std::unique_ptr<AlarmHandle> handle3(manager->PostAlarmTask(
  371. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task3->GetWeakPtr()),
  372. alarm_time));
  373. // Remove the first task.
  374. task1.reset(nullptr);
  375. // Third task should fire.
  376. clock->Advance(base::Minutes(15));
  377. task_environment_.FastForwardBy(base::Minutes(1));
  378. task_environment_.RunUntilIdle();
  379. ASSERT_FALSE(task2->fired_);
  380. ASSERT_TRUE(task3->fired_);
  381. }
  382. TEST_F(AlarmManagerTest, AlarmDeleteHandle) {
  383. std::unique_ptr<WallClockDependantTask> task1 =
  384. std::make_unique<WallClockDependantTask>();
  385. std::unique_ptr<WallClockDependantTask> task2 =
  386. std::make_unique<WallClockDependantTask>();
  387. std::unique_ptr<WallClockDependantTask> task3 =
  388. std::make_unique<WallClockDependantTask>();
  389. ASSERT_FALSE(task1->fired_);
  390. ASSERT_FALSE(task2->fired_);
  391. ASSERT_FALSE(task3->fired_);
  392. // Create the AlarmManager.
  393. base::Time now = base::Time::Now();
  394. std::unique_ptr<base::SimpleTestClock> test_clock =
  395. std::make_unique<base::SimpleTestClock>();
  396. test_clock->SetNow(now);
  397. base::SimpleTestClock* clock = test_clock.get();
  398. std::unique_ptr<AlarmManager> manager = std::make_unique<AlarmManager>(
  399. clock, base::ThreadTaskRunnerHandle::Get());
  400. // Add first task.
  401. base::Time alarm_time = now + base::Minutes(12);
  402. std::unique_ptr<AlarmHandle> handle1(manager->PostAlarmTask(
  403. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task1->GetWeakPtr()),
  404. alarm_time));
  405. // Add second task.
  406. alarm_time = now + base::Minutes(16);
  407. std::unique_ptr<AlarmHandle> handle2(manager->PostAlarmTask(
  408. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task2->GetWeakPtr()),
  409. alarm_time));
  410. // Add third task.
  411. alarm_time = now + base::Minutes(12);
  412. std::unique_ptr<AlarmHandle> handle3(manager->PostAlarmTask(
  413. base::BindOnce(&WallClockDependantTask::OnAlarmFire, task3->GetWeakPtr()),
  414. alarm_time));
  415. // Delete the first task's handle.
  416. handle1.reset();
  417. // Third task should fire.
  418. clock->Advance(base::Minutes(15));
  419. task_environment_.FastForwardBy(base::Minutes(1));
  420. task_environment_.RunUntilIdle();
  421. ASSERT_FALSE(task1->fired_);
  422. ASSERT_FALSE(task2->fired_);
  423. ASSERT_TRUE(task3->fired_);
  424. }
  425. } // namespace chromecast