| // Copyright 2019 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "power_manager/powerd/policy/charge_controller.h" |
| |
| #include <cmath> |
| #include <map> |
| #include <string> |
| #include <tuple> |
| #include <utility> |
| #include <vector> |
| |
| #include <base/strings/string_split.h> |
| #include <base/strings/string_number_conversions.h> |
| #include <base/strings/stringprintf.h> |
| #include <gtest/gtest.h> |
| |
| #include "power_manager/common/battery_percentage_converter.h" |
| #include "power_manager/common/power_constants.h" |
| #include "power_manager/powerd/system/charge_controller_helper_stub.h" |
| #include "power_manager/proto_bindings/policy.pb.h" |
| |
| namespace power_manager { |
| namespace policy { |
| |
| namespace { |
| |
| // Holds hours and minutes. |
| using TestDayConfig = std::vector<std::pair<int, int>>; |
| |
| constexpr double kLowBatteryShutdownPercent = 4.0; |
| constexpr double kFullFactor = 0.97; |
| |
| // |configs| must contain three hour/minute pairs: the start time, the end time |
| // and the charge start time. |
| void MakePeakShiftDayConfig( |
| PowerManagementPolicy::WeekDay week_day, |
| const TestDayConfig& configs, |
| PowerManagementPolicy::PeakShiftDayConfig* config_proto) { |
| DCHECK(config_proto); |
| ASSERT_EQ(configs.size(), 3); |
| |
| config_proto->set_day(week_day); |
| config_proto->mutable_start_time()->set_hour(configs[0].first); |
| config_proto->mutable_start_time()->set_minute(configs[0].second); |
| config_proto->mutable_end_time()->set_hour(configs[1].first); |
| config_proto->mutable_end_time()->set_minute(configs[1].second); |
| config_proto->mutable_charge_start_time()->set_hour(configs[2].first); |
| config_proto->mutable_charge_start_time()->set_minute(configs[2].second); |
| } |
| |
| // |configs| must contain two hour/minute pairs: the charge start time and the |
| // charge end time. |
| void MakeAdvancedBatteryChargeModeDayConfig( |
| PowerManagementPolicy::WeekDay week_day, |
| const TestDayConfig& configs, |
| PowerManagementPolicy::AdvancedBatteryChargeModeDayConfig* config_proto) { |
| DCHECK(config_proto); |
| ASSERT_EQ(configs.size(), 2); |
| |
| config_proto->set_day(week_day); |
| config_proto->mutable_charge_start_time()->set_hour(configs[0].first); |
| config_proto->mutable_charge_start_time()->set_minute(configs[0].second); |
| config_proto->mutable_charge_end_time()->set_hour(configs[1].first); |
| config_proto->mutable_charge_end_time()->set_minute(configs[1].second); |
| } |
| |
| } // namespace |
| |
| class ChargeControllerTest : public ::testing::Test { |
| public: |
| ChargeControllerTest() { |
| controller_.Init(&helper_, &battery_percentage_converter_); |
| } |
| |
| const BatteryPercentageConverter& battery_percentage_converter() const { |
| return battery_percentage_converter_; |
| } |
| |
| const system::ChargeControllerHelperStub& helper() const { return helper_; } |
| |
| protected: |
| // Sets PeakShift policy in PowerManagementPolicy proto. |
| void SetPeakShift(int threshold, |
| const std::map<PowerManagementPolicy::WeekDay, |
| TestDayConfig>& day_configs) { |
| policy_.set_peak_shift_battery_percent_threshold(threshold); |
| policy_.mutable_peak_shift_day_configs()->Clear(); |
| for (const auto& item : day_configs) { |
| MakePeakShiftDayConfig(item.first, item.second, |
| policy_.add_peak_shift_day_configs()); |
| } |
| } |
| |
| // Checks that PeakShift policy was applied as expected. |
| bool CheckPeakShift(bool enable, |
| int threshold, |
| const std::map<PowerManagementPolicy::WeekDay, |
| std::string>& day_configs) { |
| for (const auto& item : day_configs) { |
| EXPECT_EQ(helper_.peak_shift_day_config(item.first), item.second); |
| if (helper_.peak_shift_day_config(item.first) != item.second) { |
| return false; |
| } |
| } |
| EXPECT_EQ(helper_.peak_shift_enabled(), enable); |
| EXPECT_EQ(helper_.peak_shift_threshold(), threshold); |
| return helper_.peak_shift_enabled() == enable && |
| helper_.peak_shift_threshold() == threshold; |
| } |
| |
| // Sets AdvancedBatteryChargeMode policy in PowerManagementPolicy proto. |
| void SetAdvancedBatteryChargeMode( |
| const std::map<PowerManagementPolicy::WeekDay, TestDayConfig>& |
| day_configs) { |
| policy_.mutable_advanced_battery_charge_mode_day_configs()->Clear(); |
| for (const auto& item : day_configs) { |
| MakeAdvancedBatteryChargeModeDayConfig( |
| item.first, item.second, |
| policy_.add_advanced_battery_charge_mode_day_configs()); |
| } |
| } |
| |
| // Checks that AdvancedBatteryChargeMode policy was applied as expected. |
| bool CheckAdvancedBatteryChargeMode( |
| bool enable, |
| const std::map<PowerManagementPolicy::WeekDay, std::string>& |
| day_configs) { |
| for (const auto& item : day_configs) { |
| EXPECT_EQ(helper_.advanced_battery_charge_mode_day_config(item.first), |
| item.second); |
| if (helper_.advanced_battery_charge_mode_day_config(item.first) != |
| item.second) { |
| return false; |
| } |
| } |
| EXPECT_EQ(helper_.advanced_battery_charge_mode_enabled(), enable); |
| return helper_.advanced_battery_charge_mode_enabled() == enable; |
| } |
| |
| // Sets BatteryChargeMode policy in PowerManagementPolicy proto. |
| void SetBatteryChargeMode(PowerManagementPolicy::BatteryChargeMode::Mode mode, |
| int custom_charge_start, |
| int custom_charge_stop) { |
| policy_.mutable_battery_charge_mode()->set_mode(mode); |
| policy_.mutable_battery_charge_mode()->set_custom_charge_start( |
| custom_charge_start); |
| policy_.mutable_battery_charge_mode()->set_custom_charge_stop( |
| custom_charge_stop); |
| } |
| |
| // Checks that BatteryChargeMode policy was applied as expected. |
| bool CheckBatteryChargeMode( |
| PowerManagementPolicy::BatteryChargeMode::Mode mode, |
| int custom_charge_start = |
| system::ChargeControllerHelperStub::kCustomChargeThresholdUnset, |
| int custom_charge_stop = |
| system::ChargeControllerHelperStub::kCustomChargeThresholdUnset) { |
| EXPECT_EQ(helper_.battery_charge_mode(), mode); |
| EXPECT_EQ(helper_.custom_charge_start(), custom_charge_start); |
| EXPECT_EQ(helper_.custom_charge_stop(), custom_charge_stop); |
| return helper_.battery_charge_mode() == mode && |
| helper_.custom_charge_start() == custom_charge_start && |
| helper_.custom_charge_stop() == custom_charge_stop; |
| } |
| |
| system::ChargeControllerHelperStub helper_; |
| |
| ChargeController controller_; |
| PowerManagementPolicy policy_; |
| |
| private: |
| BatteryPercentageConverter battery_percentage_converter_{ |
| kLowBatteryShutdownPercent, kFullFactor}; |
| }; |
| |
| TEST_F(ChargeControllerTest, PeakShiftNoPolicies) { |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_FALSE(helper_.peak_shift_enabled()); |
| } |
| |
| TEST_F(ChargeControllerTest, PeakShiftThresholdOnly) { |
| constexpr int kThreshold = 50; |
| policy_.set_peak_shift_battery_percent_threshold(kThreshold); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_FALSE(helper_.peak_shift_enabled()); |
| } |
| |
| TEST_F(ChargeControllerTest, PeakShiftDayConfigsOnly) { |
| constexpr PowerManagementPolicy::WeekDay kDay = PowerManagementPolicy::MONDAY; |
| const TestDayConfig kDayConfig{{0, 30}, {9, 45}, {20, 0}}; |
| |
| MakePeakShiftDayConfig(kDay, kDayConfig, |
| policy_.add_peak_shift_day_configs()); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_FALSE(helper_.peak_shift_enabled()); |
| } |
| |
| TEST_F(ChargeControllerTest, PeakShift) { |
| constexpr int kThreshold1 = 50; |
| constexpr int kThreshold2 = 45; |
| constexpr int kThreshold3 = 10; |
| |
| const int actual_threshold1 = std::round( |
| battery_percentage_converter().ConvertDisplayToActual(kThreshold1)); |
| const int actual_threshold2 = std::round( |
| battery_percentage_converter().ConvertDisplayToActual(kThreshold2)); |
| // |kThreshold3| after converting to actual battery percentage will be less |
| // than min allowed value. |
| const int actual_threshold3 = ChargeController::kPeakShiftBatteryThresholdMin; |
| |
| constexpr PowerManagementPolicy::WeekDay kDay1 = |
| PowerManagementPolicy::MONDAY; |
| constexpr PowerManagementPolicy::WeekDay kDay2 = |
| PowerManagementPolicy::FRIDAY; |
| |
| const TestDayConfig kDayConfig1{{0, 30}, {9, 45}, {20, 0}}; |
| constexpr char kExpectedDayConfig1[] = "00:30 09:45 20:00"; |
| |
| const TestDayConfig kDayConfig2{{9, 15}, {10, 0}, {23, 15}}; |
| constexpr char kExpectedDayConfig2[] = "09:15 10:00 23:15"; |
| |
| SetPeakShift(kThreshold1, {{kDay1, kDayConfig1}, {kDay2, kDayConfig2}}); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckPeakShift( |
| true, actual_threshold1, |
| {{kDay1, kExpectedDayConfig1}, {kDay2, kExpectedDayConfig2}})); |
| |
| SetPeakShift(kThreshold2, {{kDay1, kDayConfig2}, {kDay2, kDayConfig1}}); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckPeakShift( |
| true, actual_threshold2, |
| {{kDay1, kExpectedDayConfig2}, {kDay2, kExpectedDayConfig1}})); |
| |
| SetPeakShift(kThreshold3, {{kDay1, kDayConfig2}, {kDay2, kDayConfig1}}); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckPeakShift( |
| true, actual_threshold3, |
| {{kDay1, kExpectedDayConfig2}, {kDay2, kExpectedDayConfig1}})); |
| |
| helper_.Reset(); |
| |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckPeakShift( |
| false, system::ChargeControllerHelperStub::kPeakShiftThresholdUnset, |
| {{kDay1, ""}, {kDay2, ""}})); |
| } |
| |
| TEST_F(ChargeControllerTest, BootOnAc) { |
| policy_.set_boot_on_ac(false); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_FALSE(helper_.boot_on_ac_enabled()); |
| |
| policy_.set_boot_on_ac(true); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(helper_.boot_on_ac_enabled()); |
| |
| helper_.Reset(); |
| |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_FALSE(helper_.boot_on_ac_enabled()); |
| } |
| |
| TEST_F(ChargeControllerTest, UsbPowerShare) { |
| policy_.set_usb_power_share(false); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_FALSE(helper_.usb_power_share_enabled()); |
| |
| policy_.set_usb_power_share(true); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(helper_.usb_power_share_enabled()); |
| |
| helper_.Reset(); |
| |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_FALSE(helper_.usb_power_share_enabled()); |
| } |
| |
| TEST_F(ChargeControllerTest, AdvancedBatteryChargeModeEnabledNoPolicies) { |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_FALSE(helper_.advanced_battery_charge_mode_enabled()); |
| } |
| |
| TEST_F(ChargeControllerTest, AdvancedBatteryChargeMode) { |
| constexpr PowerManagementPolicy::WeekDay kDay1 = |
| PowerManagementPolicy::TUESDAY; |
| constexpr PowerManagementPolicy::WeekDay kDay2 = |
| PowerManagementPolicy::SUNDAY; |
| |
| const TestDayConfig kDayConfigStartEnd1{{2, 45}, {8, 30}}; |
| constexpr char kExpectedDayConfigStartDuration1[] = "02:45 05:45"; |
| |
| const TestDayConfig kDayConfigStartEnd2{{3, 30}, {16, 0}}; |
| constexpr char kExpectedDayConfigStartDuration2[] = "03:30 12:30"; |
| |
| SetAdvancedBatteryChargeMode( |
| {{kDay1, kDayConfigStartEnd1}, {kDay2, kDayConfigStartEnd2}}); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckAdvancedBatteryChargeMode( |
| true, {{kDay1, kExpectedDayConfigStartDuration1}, |
| {kDay2, kExpectedDayConfigStartDuration2}})); |
| |
| SetAdvancedBatteryChargeMode( |
| {{kDay1, kDayConfigStartEnd2}, {kDay2, kDayConfigStartEnd1}}); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckAdvancedBatteryChargeMode( |
| true, {{kDay1, kExpectedDayConfigStartDuration2}, |
| {kDay2, kExpectedDayConfigStartDuration1}})); |
| |
| helper_.Reset(); |
| |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE( |
| CheckAdvancedBatteryChargeMode(false, {{kDay1, ""}, {kDay2, ""}})); |
| } |
| |
| TEST_F(ChargeControllerTest, BatteryChargeModeNoPolicies) { |
| EXPECT_TRUE(CheckBatteryChargeMode( |
| system::ChargeControllerHelperStub::kBatteryChargeModeUnset)); |
| |
| controller_.HandlePolicyChange(policy_); |
| |
| EXPECT_TRUE(CheckBatteryChargeMode( |
| PowerManagementPolicy::BatteryChargeMode::STANDARD)); |
| } |
| |
| TEST_F(ChargeControllerTest, BatteryChargeMode) { |
| constexpr PowerManagementPolicy::BatteryChargeMode::Mode kMode1 = |
| PowerManagementPolicy::BatteryChargeMode::PRIMARILY_AC_USE; |
| constexpr PowerManagementPolicy::BatteryChargeMode::Mode kMode2 = |
| PowerManagementPolicy::BatteryChargeMode::CUSTOM; |
| constexpr int kCustomStartCharge = 60; |
| constexpr int kCustomEndCharge = 90; |
| |
| const int actual_custom_start_charge = |
| std::round(battery_percentage_converter().ConvertDisplayToActual( |
| kCustomStartCharge)); |
| const int actual_custom_end_charge = std::round( |
| battery_percentage_converter().ConvertDisplayToActual(kCustomEndCharge)); |
| |
| policy_.mutable_battery_charge_mode()->set_mode(kMode1); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckBatteryChargeMode(kMode1)); |
| |
| SetBatteryChargeMode(kMode2, kCustomStartCharge, kCustomEndCharge); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckBatteryChargeMode(kMode2, actual_custom_start_charge, |
| actual_custom_end_charge)); |
| |
| helper_.Reset(); |
| |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckBatteryChargeMode( |
| system::ChargeControllerHelperStub::kBatteryChargeModeUnset)); |
| } |
| |
| TEST_F(ChargeControllerTest, BatteryChargeModeInvalidThresholds) { |
| constexpr PowerManagementPolicy::BatteryChargeMode::Mode kMode1 = |
| PowerManagementPolicy::BatteryChargeMode::PRIMARILY_AC_USE; |
| constexpr PowerManagementPolicy::BatteryChargeMode::Mode kMode2 = |
| PowerManagementPolicy::BatteryChargeMode::CUSTOM; |
| constexpr int kCustomStartCharge = 79; |
| constexpr int kCustomEndCharge = 80; |
| |
| const int actual_custom_end_charge = std::round( |
| battery_percentage_converter().ConvertDisplayToActual(kCustomEndCharge)); |
| int actual_custom_start_charge = |
| std::round(battery_percentage_converter().ConvertDisplayToActual( |
| kCustomStartCharge)); |
| |
| // Verify that ChargeController clamps |start| and |end| thresholds within min |
| // and max range and keeps min difference between them. |
| EXPECT_LT(actual_custom_end_charge - actual_custom_start_charge, |
| ChargeController::kCustomChargeModeThresholdsMinDiff); |
| actual_custom_start_charge = |
| actual_custom_end_charge - |
| ChargeController::kCustomChargeModeThresholdsMinDiff; |
| |
| policy_.mutable_battery_charge_mode()->set_mode(kMode1); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckBatteryChargeMode(kMode1)); |
| |
| SetBatteryChargeMode(kMode2, kCustomStartCharge, kCustomEndCharge); |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckBatteryChargeMode(kMode2, actual_custom_start_charge, |
| actual_custom_end_charge)); |
| |
| helper_.Reset(); |
| |
| controller_.HandlePolicyChange(policy_); |
| EXPECT_TRUE(CheckBatteryChargeMode( |
| system::ChargeControllerHelperStub::kBatteryChargeModeUnset)); |
| } |
| |
| // If AdvancedBatteryChargeMode is specified, it overrides BatteryChargeMode. |
| TEST_F(ChargeControllerTest, |
| AdvancedBatteryChargeModeOverridesBatteryChargeMode) { |
| constexpr PowerManagementPolicy::BatteryChargeMode::Mode kMode = |
| PowerManagementPolicy::BatteryChargeMode::EXPRESS_CHARGE; |
| |
| constexpr PowerManagementPolicy::WeekDay kDay1 = |
| PowerManagementPolicy::FRIDAY; |
| constexpr PowerManagementPolicy::WeekDay kDay2 = |
| PowerManagementPolicy::SUNDAY; |
| |
| const TestDayConfig kDayConfigStartEnd1{{8, 15}, {10, 45}}; |
| constexpr char kExpectedDayConfigStartDuration1[] = "08:15 02:30"; |
| |
| const TestDayConfig kDayConfigStartEnd2{{4, 0}, {6, 15}}; |
| constexpr char kExpectedDayConfigStartDuration2[] = "04:00 02:15"; |
| |
| policy_.mutable_battery_charge_mode()->set_mode(kMode); |
| SetAdvancedBatteryChargeMode( |
| {{kDay1, kDayConfigStartEnd1}, {kDay2, kDayConfigStartEnd2}}); |
| |
| controller_.HandlePolicyChange(policy_); |
| |
| EXPECT_EQ(helper_.battery_charge_mode(), |
| system::ChargeControllerHelperStub::kBatteryChargeModeUnset); |
| EXPECT_TRUE(CheckAdvancedBatteryChargeMode( |
| true, {{kDay1, kExpectedDayConfigStartDuration1}, |
| {kDay2, kExpectedDayConfigStartDuration2}})); |
| } |
| |
| struct CustomChargeThresholdsTestData { |
| // (start, end) input thresholds. |
| std::pair<int, int> input; |
| // (start, end) expected thresholds. |
| std::pair<int, int> expected; |
| }; |
| |
| class CustomChargeThresholdsChargeControllerTest |
| : public ::testing::Test, |
| public testing::WithParamInterface<CustomChargeThresholdsTestData> { |
| public: |
| int input_start_threshold() const { return GetParam().input.first; } |
| int input_end_threshold() const { return GetParam().input.second; } |
| |
| int expected_start_threshold() const { return GetParam().expected.first; } |
| int expected_end_threshold() const { return GetParam().expected.second; } |
| }; |
| |
| TEST_P(CustomChargeThresholdsChargeControllerTest, All) { |
| int start = input_start_threshold(); |
| int end = input_end_threshold(); |
| ChargeController::ClampCustomBatteryChargeThresholds(&start, &end); |
| EXPECT_EQ(start, expected_start_threshold()); |
| EXPECT_EQ(end, expected_end_threshold()); |
| EXPECT_GE(end - start, ChargeController::kCustomChargeModeThresholdsMinDiff); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| _, |
| CustomChargeThresholdsChargeControllerTest, |
| testing::Values( |
| // Valid thresholds. |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMin}, |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMin}}, |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMax, |
| ChargeController::kCustomChargeModeEndMax}, |
| {ChargeController::kCustomChargeModeStartMax, |
| ChargeController::kCustomChargeModeEndMax}}, |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMax}, |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMax}}, |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMin + 1, |
| ChargeController::kCustomChargeModeEndMax - 1}, |
| {ChargeController::kCustomChargeModeStartMin + 1, |
| ChargeController::kCustomChargeModeEndMax - 1}}, |
| |
| // |start| threshold less than min value. |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMin - 1, |
| ChargeController::kCustomChargeModeEndMax}, |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMax}}, |
| |
| // |start| threshold greater than max value. |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMax + 1, |
| ChargeController::kCustomChargeModeEndMax}, |
| {ChargeController::kCustomChargeModeStartMax, |
| ChargeController::kCustomChargeModeEndMax}}, |
| |
| // |end| threshold less than min value. |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMin - 1}, |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMin}}, |
| |
| // |end| threshold greater than max value. |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMax + 1}, |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMax}}, |
| |
| // Diff between |start| and |end| threshold less than allowed min diff. |
| // Thresholds close to their min values. |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMin + 1, |
| ChargeController::kCustomChargeModeEndMin}, |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMin}}, |
| |
| // Diff between |start| and |end| threshold less than allowed min diff. |
| // Also |end| threshold less than min value. |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMin - 1}, |
| {ChargeController::kCustomChargeModeStartMin, |
| ChargeController::kCustomChargeModeEndMin}}, |
| |
| // Diff between |start| and |end| threshold less than allowed min diff. |
| // Thresholds between their min and max values. |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMin + 19, |
| ChargeController::kCustomChargeModeStartMin + 20}, |
| {ChargeController::kCustomChargeModeStartMin + 15, |
| ChargeController::kCustomChargeModeStartMin + 20}}, |
| |
| // Diff between |start| and |end| threshold less than allowed min diff. |
| // Thresholds close to their max values. |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMax, |
| ChargeController::kCustomChargeModeEndMax - 1}, |
| {ChargeController::kCustomChargeModeStartMax - 1, |
| ChargeController::kCustomChargeModeEndMax - 1}}, |
| |
| // Diff between |start| and |end| threshold less than allowed min diff. |
| // Also |start| threshold greater than max value. |
| CustomChargeThresholdsTestData{ |
| {ChargeController::kCustomChargeModeStartMax + 1, |
| ChargeController::kCustomChargeModeEndMax}, |
| {ChargeController::kCustomChargeModeStartMax, |
| ChargeController::kCustomChargeModeEndMax}})); |
| |
| class PeakShiftThresholdChargeControllerTest |
| : public ::testing::Test, |
| public testing::WithParamInterface<std::tuple<int, int>> { |
| public: |
| int input_threshold() const { return std::get<0>(GetParam()); } |
| |
| int expected_threshold() const { return std::get<1>(GetParam()); } |
| }; |
| |
| // Verifies that display percentage threshold for peak shift will be converted |
| // into valid actual percentage threshold. |
| TEST_P(PeakShiftThresholdChargeControllerTest, ValidActualThreshold) { |
| const int actual_threshold = |
| ChargeController::ClampPeakShiftBatteryThreshold(input_threshold()); |
| EXPECT_EQ(actual_threshold, expected_threshold()); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| _, |
| PeakShiftThresholdChargeControllerTest, |
| testing::Values( |
| // Valid values. |
| std::make_tuple(ChargeController::kPeakShiftBatteryThresholdMin, |
| ChargeController::kPeakShiftBatteryThresholdMin), |
| std::make_tuple(ChargeController::kPeakShiftBatteryThresholdMax, |
| ChargeController::kPeakShiftBatteryThresholdMax), |
| std::make_tuple(ChargeController::kPeakShiftBatteryThresholdMin + 20, |
| ChargeController::kPeakShiftBatteryThresholdMin + 20), |
| |
| // Threshold less than min value. |
| std::make_tuple(ChargeController::kPeakShiftBatteryThresholdMin - 1, |
| ChargeController::kPeakShiftBatteryThresholdMin), |
| |
| // Threshold greater than max value. |
| std::make_tuple(ChargeController::kPeakShiftBatteryThresholdMax + 1, |
| ChargeController::kPeakShiftBatteryThresholdMax))); |
| |
| } // namespace policy |
| } // namespace power_manager |
