power_monitor_unittest.cc 8.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246
  1. // Copyright 2013 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 "base/power_monitor/power_monitor.h"
  5. #include "base/test/power_monitor_test.h"
  6. #include "base/test/task_environment.h"
  7. #include "testing/gtest/include/gtest/gtest.h"
  8. #include "third_party/abseil-cpp/absl/types/optional.h"
  9. namespace base {
  10. namespace test {
  11. class PowerMonitorTest : public testing::Test {
  12. public:
  13. PowerMonitorTest(const PowerMonitorTest&) = delete;
  14. PowerMonitorTest& operator=(const PowerMonitorTest&) = delete;
  15. protected:
  16. PowerMonitorTest() = default;
  17. void PowerMonitorInitialize() { power_monitor_source_.emplace(); }
  18. ScopedPowerMonitorTestSource& source() {
  19. return power_monitor_source_.value();
  20. }
  21. private:
  22. TaskEnvironment task_environment_;
  23. absl::optional<ScopedPowerMonitorTestSource> power_monitor_source_;
  24. };
  25. // PowerMonitorSource is tightly coupled with the PowerMonitor, so this test
  26. // covers both classes.
  27. TEST_F(PowerMonitorTest, PowerNotifications) {
  28. const int kObservers = 5;
  29. PowerMonitorInitialize();
  30. PowerMonitorTestObserver observers[kObservers];
  31. for (auto& index : observers) {
  32. PowerMonitor::AddPowerSuspendObserver(&index);
  33. PowerMonitor::AddPowerStateObserver(&index);
  34. PowerMonitor::AddPowerThermalObserver(&index);
  35. }
  36. // Sending resume when not suspended should have no effect.
  37. source().GenerateResumeEvent();
  38. EXPECT_EQ(observers[0].resumes(), 0);
  39. // Pretend we suspended.
  40. source().GenerateSuspendEvent();
  41. // Ensure all observers were notified of the event
  42. for (const auto& index : observers)
  43. EXPECT_EQ(index.suspends(), 1);
  44. // Send a second suspend notification. This should be suppressed.
  45. source().GenerateSuspendEvent();
  46. EXPECT_EQ(observers[0].suspends(), 1);
  47. // Pretend we were awakened.
  48. source().GenerateResumeEvent();
  49. EXPECT_EQ(observers[0].resumes(), 1);
  50. // Send a duplicate resume notification. This should be suppressed.
  51. source().GenerateResumeEvent();
  52. EXPECT_EQ(observers[0].resumes(), 1);
  53. // Pretend the device has gone on battery power
  54. source().GeneratePowerStateEvent(true);
  55. EXPECT_EQ(observers[0].power_state_changes(), 1);
  56. EXPECT_EQ(observers[0].last_power_state(), true);
  57. // Repeated indications the device is on battery power should be suppressed.
  58. source().GeneratePowerStateEvent(true);
  59. EXPECT_EQ(observers[0].power_state_changes(), 1);
  60. // Pretend the device has gone off battery power
  61. source().GeneratePowerStateEvent(false);
  62. EXPECT_EQ(observers[0].power_state_changes(), 2);
  63. EXPECT_EQ(observers[0].last_power_state(), false);
  64. // Repeated indications the device is off battery power should be suppressed.
  65. source().GeneratePowerStateEvent(false);
  66. EXPECT_EQ(observers[0].power_state_changes(), 2);
  67. // Send speed limit change notifications.
  68. source().GenerateSpeedLimitEvent(666);
  69. EXPECT_EQ(observers[0].speed_limit_changes(), 1);
  70. EXPECT_EQ(observers[0].last_speed_limit(), 666);
  71. source().GenerateSpeedLimitEvent(777);
  72. EXPECT_EQ(observers[0].speed_limit_changes(), 2);
  73. EXPECT_EQ(observers[0].last_speed_limit(), 777);
  74. EXPECT_EQ(observers[0].thermal_state_changes(), 0);
  75. // Send a power thermal change notification.
  76. source().GenerateThermalThrottlingEvent(
  77. PowerThermalObserver::DeviceThermalState::kNominal);
  78. EXPECT_EQ(observers[0].thermal_state_changes(), 1);
  79. EXPECT_EQ(observers[0].last_thermal_state(),
  80. PowerThermalObserver::DeviceThermalState::kNominal);
  81. // Send a duplicate power thermal notification. This should be suppressed.
  82. source().GenerateThermalThrottlingEvent(
  83. PowerThermalObserver::DeviceThermalState::kNominal);
  84. EXPECT_EQ(observers[0].thermal_state_changes(), 1);
  85. // Send a different power thermal change notification.
  86. source().GenerateThermalThrottlingEvent(
  87. PowerThermalObserver::DeviceThermalState::kFair);
  88. EXPECT_EQ(observers[0].thermal_state_changes(), 2);
  89. EXPECT_EQ(observers[0].last_thermal_state(),
  90. PowerThermalObserver::DeviceThermalState::kFair);
  91. for (auto& index : observers) {
  92. PowerMonitor::RemovePowerSuspendObserver(&index);
  93. PowerMonitor::RemovePowerStateObserver(&index);
  94. PowerMonitor::RemovePowerThermalObserver(&index);
  95. }
  96. }
  97. TEST_F(PowerMonitorTest, ThermalThrottling) {
  98. PowerMonitorTestObserver observer;
  99. PowerMonitor::AddPowerThermalObserver(&observer);
  100. PowerMonitorInitialize();
  101. constexpr PowerThermalObserver::DeviceThermalState kThermalStates[] = {
  102. PowerThermalObserver::DeviceThermalState::kUnknown,
  103. PowerThermalObserver::DeviceThermalState::kNominal,
  104. PowerThermalObserver::DeviceThermalState::kFair,
  105. PowerThermalObserver::DeviceThermalState::kSerious,
  106. PowerThermalObserver::DeviceThermalState::kCritical};
  107. for (const auto state : kThermalStates) {
  108. source().GenerateThermalThrottlingEvent(state);
  109. EXPECT_EQ(state, source().GetCurrentThermalState());
  110. EXPECT_EQ(observer.last_thermal_state(), state);
  111. }
  112. PowerMonitor::RemovePowerThermalObserver(&observer);
  113. }
  114. TEST_F(PowerMonitorTest, AddPowerSuspendObserverBeforeAndAfterInitialization) {
  115. PowerMonitorTestObserver observer1;
  116. PowerMonitorTestObserver observer2;
  117. // An observer is added before the PowerMonitor initialization.
  118. PowerMonitor::AddPowerSuspendObserver(&observer1);
  119. PowerMonitorInitialize();
  120. // An observer is added after the PowerMonitor initialization.
  121. PowerMonitor::AddPowerSuspendObserver(&observer2);
  122. // Simulate suspend/resume notifications.
  123. source().GenerateSuspendEvent();
  124. EXPECT_EQ(observer1.suspends(), 1);
  125. EXPECT_EQ(observer2.suspends(), 1);
  126. EXPECT_EQ(observer1.resumes(), 0);
  127. EXPECT_EQ(observer2.resumes(), 0);
  128. source().GenerateResumeEvent();
  129. EXPECT_EQ(observer1.resumes(), 1);
  130. EXPECT_EQ(observer2.resumes(), 1);
  131. PowerMonitor::RemovePowerSuspendObserver(&observer1);
  132. PowerMonitor::RemovePowerSuspendObserver(&observer2);
  133. }
  134. TEST_F(PowerMonitorTest, AddPowerStateObserverBeforeAndAfterInitialization) {
  135. PowerMonitorTestObserver observer1;
  136. PowerMonitorTestObserver observer2;
  137. // An observer is added before the PowerMonitor initialization.
  138. PowerMonitor::AddPowerStateObserver(&observer1);
  139. PowerMonitorInitialize();
  140. // An observer is added after the PowerMonitor initialization.
  141. PowerMonitor::AddPowerStateObserver(&observer2);
  142. // Simulate power state transitions (e.g. battery on/off).
  143. EXPECT_EQ(observer1.power_state_changes(), 0);
  144. EXPECT_EQ(observer2.power_state_changes(), 0);
  145. source().GeneratePowerStateEvent(true);
  146. EXPECT_EQ(observer1.power_state_changes(), 1);
  147. EXPECT_EQ(observer2.power_state_changes(), 1);
  148. source().GeneratePowerStateEvent(false);
  149. EXPECT_EQ(observer1.power_state_changes(), 2);
  150. EXPECT_EQ(observer2.power_state_changes(), 2);
  151. PowerMonitor::RemovePowerStateObserver(&observer1);
  152. PowerMonitor::RemovePowerStateObserver(&observer2);
  153. }
  154. TEST_F(PowerMonitorTest, SuspendStateReturnedFromAddObserver) {
  155. PowerMonitorTestObserver observer1;
  156. PowerMonitorTestObserver observer2;
  157. PowerMonitorInitialize();
  158. EXPECT_FALSE(
  159. PowerMonitor::AddPowerSuspendObserverAndReturnSuspendedState(&observer1));
  160. source().GenerateSuspendEvent();
  161. EXPECT_TRUE(
  162. PowerMonitor::AddPowerSuspendObserverAndReturnSuspendedState(&observer2));
  163. EXPECT_EQ(observer1.suspends(), 1);
  164. EXPECT_EQ(observer2.suspends(), 0);
  165. EXPECT_EQ(observer1.resumes(), 0);
  166. EXPECT_EQ(observer2.resumes(), 0);
  167. PowerMonitor::RemovePowerSuspendObserver(&observer1);
  168. PowerMonitor::RemovePowerSuspendObserver(&observer2);
  169. }
  170. TEST_F(PowerMonitorTest, PowerStateReturnedFromAddObserver) {
  171. PowerMonitorTestObserver observer1;
  172. PowerMonitorTestObserver observer2;
  173. PowerMonitorInitialize();
  174. // An observer is added before the on-battery notification.
  175. EXPECT_FALSE(
  176. PowerMonitor::AddPowerStateObserverAndReturnOnBatteryState(&observer1));
  177. source().GeneratePowerStateEvent(true);
  178. // An observer is added after the on-battery notification.
  179. EXPECT_TRUE(
  180. PowerMonitor::AddPowerStateObserverAndReturnOnBatteryState(&observer2));
  181. EXPECT_EQ(observer1.power_state_changes(), 1);
  182. EXPECT_EQ(observer2.power_state_changes(), 0);
  183. PowerMonitor::RemovePowerStateObserver(&observer1);
  184. PowerMonitor::RemovePowerStateObserver(&observer2);
  185. }
  186. } // namespace test
  187. } // namespace base