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