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