// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "ash/system/power/battery_saver_controller.h"

#include <memory>

#include "ash/constants/ash_features.h"
#include "ash/constants/ash_pref_names.h"
#include "ash/shell.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/system/power/battery_notification.h"
#include "ash/system/power/power_status.h"
#include "ash/system/system_notification_controller.h"
#include "ash/system/toast/toast_manager_impl.h"
#include "ash/system/toast/toast_overlay.h"
#include "ash/test/ash_test_base.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "chromeos/dbus/power/fake_power_manager_client.h"
#include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/message_center/message_center.h"

namespace ash {

class BatterySaverControllerTest : public AshTestBase {
 public:
  // AshTestBase:
  void SetUp() override {
    scoped_feature_list_ = std::make_unique<base::test::ScopedFeatureList>(
        features::kBatterySaver);
    chromeos::PowerManagerClient::InitializeFake();
    AshTestBase::SetUp();

    // Let initial PowerStatus call to
    // PowerManagerClient::GetBatterySaverModeState to complete.
    base::RunLoop run_loop;
    run_loop.RunUntilIdle();
  }

  void TearDown() override {
    AshTestBase::TearDown();
    chromeos::PowerManagerClient::Shutdown();
    scoped_feature_list_.reset();
  }

 protected:
  BatterySaverController* battery_saver_controller() {
    return Shell::Get()->battery_saver_controller();
  }

  void UpdatePowerStatus(double battery_percent,
                         base::TimeDelta time_to_empty,
                         bool charging,
                         bool is_usb_charger = false) {
    power_manager::PowerSupplyProperties props;

    // Set battery percentage
    props.set_battery_percent(battery_percent);

    // Determine battery state
    auto external_power =
        power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED;
    auto battery_state =
        power_manager::PowerSupplyProperties_BatteryState_DISCHARGING;

    if (is_usb_charger) {
      external_power = power_manager::PowerSupplyProperties_ExternalPower_USB;
    } else if (charging) {  // Otherwise, treat like AC charger.
      external_power = power_manager::PowerSupplyProperties_ExternalPower_AC;
    }

    if (battery_percent >= 100) {
      battery_state = power_manager::PowerSupplyProperties_BatteryState_FULL;
    } else if (charging) {
      battery_state =
          power_manager::PowerSupplyProperties_BatteryState_CHARGING;
    }

    // Set battery state
    props.set_external_power(external_power);
    props.set_battery_state(battery_state);

    // Set time
    props.set_is_calculating_battery_time(false);
    props.set_battery_time_to_empty_sec(time_to_empty.InSecondsF());

    // Flush
    base::RunLoop run_loop;
    chromeos::FakePowerManagerClient::Get()->UpdatePowerProperties(props);
    run_loop.RunUntilIdle();
  }

  ToastOverlay* GetCurrentToast() {
    return Shell::Get()->toast_manager()->GetCurrentOverlayForTesting();
  }

  void DismissToast() {
    Shell::Get()->toast_manager()->CloseAllToastsWithAnimation();
  }

  bool IsBatterySaverActive() {
    return PowerStatus::Get()->IsBatterySaverActive();
  }

  double GetActivationPercent() {
    return features::kBatterySaverActivationChargePercent.Get();
  }

  constexpr static base::TimeDelta eight_hours_ = base::Hours(8);

  std::unique_ptr<base::test::ScopedFeatureList> scoped_feature_list_ = nullptr;
};

class BatterySaverControllerNotificationTest
    : public BatterySaverControllerTest,
      public testing::WithParamInterface<
          features::BatterySaverNotificationBehavior> {
 protected:
  message_center::Notification* GetCurrentNotification() {
    return message_center::MessageCenter::Get()->FindNotificationById(
        BatteryNotification::kNotificationId);
  }

  void DismissNotification() {
    message_center::MessageCenter::Get()->RemoveNotification(
        BatteryNotification::kNotificationId, false);
    EXPECT_EQ(GetCurrentNotification(), nullptr);
  }

  void NotificationNotPresent() {
    EXPECT_EQ(GetCurrentNotification(), nullptr);
  }

  void NotificationPresent() { EXPECT_NE(GetCurrentNotification(), nullptr); }

  void SetExperimentArm(features::BatterySaverNotificationBehavior arm) {
    scoped_feature_list_.reset();
    base::FieldTrialParams parameters;
    parameters[features::kBatterySaverNotificationBehavior.name] =
        features::kBatterySaverNotificationBehavior.options[arm].name;
    scoped_feature_list_ = std::make_unique<base::test::ScopedFeatureList>();
    scoped_feature_list_->InitAndEnableFeatureWithParameters(
        features::kBatterySaver, parameters);
    base::RunLoop run_loop;
    run_loop.RunUntilIdle();
  }
};

// Test that the automatic logic to turn battery saver on and off without
// direct user action works.
TEST_F(BatterySaverControllerTest, AutoEnableDisable) {
  // Battery near full and charging, no battery saver.
  UpdatePowerStatus(80.0, eight_hours_, true);
  EXPECT_FALSE(IsBatterySaverActive());

  // Battery near full and discharging, still no battery saver.
  UpdatePowerStatus(80.0, eight_hours_, false);
  EXPECT_FALSE(IsBatterySaverActive());

  // Battery discharging but just above the activation %, still no battery
  // saver.
  UpdatePowerStatus(GetActivationPercent() + 1, eight_hours_, false);
  EXPECT_FALSE(IsBatterySaverActive());

  // Battery discharging and at activation %, battery saver turns on.
  UpdatePowerStatus(GetActivationPercent(), eight_hours_, false);
  EXPECT_TRUE(IsBatterySaverActive());

  // Discharge more, battery saver remains on.
  UpdatePowerStatus(5.0, eight_hours_, false);
  EXPECT_TRUE(IsBatterySaverActive());

  // Start charging, even with a low battery %, battery saver disables.
  UpdatePowerStatus(5.0, eight_hours_, true);
  EXPECT_FALSE(IsBatterySaverActive());
}

// Test that we detect charging while asleep, as seen by a sudden jump in charge
// while discharging.
TEST_F(BatterySaverControllerTest, DetectSleepCharging) {
  // Battery discharging and below activation %, battery saver turns on.
  UpdatePowerStatus(5.0, eight_hours_, false);
  EXPECT_TRUE(IsBatterySaverActive());

  // Increase charge while still discharging, but stay below activiation %,
  // battery saver remains on.
  UpdatePowerStatus(GetActivationPercent(), eight_hours_, false);
  EXPECT_TRUE(IsBatterySaverActive());

  // Increase charge again, but this time above the activation %, battery saver
  // turns off.
  UpdatePowerStatus(
      GetActivationPercent() +
          BatterySaverController::kBatterySaverSleepChargeThreshold,
      eight_hours_, false);
  EXPECT_FALSE(IsBatterySaverActive());
}

TEST_F(BatterySaverControllerTest, EnsureThresholdsCrossed) {
  // Start the test with full battery, discharging.
  UpdatePowerStatus(100.0, eight_hours_, false);
  EXPECT_FALSE(IsBatterySaverActive());

  // Enable battery saver mode manually.
  battery_saver_controller()->SetState(
      true, BatterySaverController::UpdateReason::kSettings);

  // Discharge to the percent threshold
  UpdatePowerStatus(GetActivationPercent(), eight_hours_, false);
  EXPECT_TRUE(IsBatterySaverActive());

  // Disable battery saver mode manually.
  battery_saver_controller()->SetState(
      false, BatterySaverController::UpdateReason::kSettings);

  // When we get to percent_threshold-1, it should still be disabled.
  UpdatePowerStatus(GetActivationPercent() - 1, eight_hours_, false);
  EXPECT_FALSE(IsBatterySaverActive());
}

// Test that Battery Saver remains enabled when charging with a low power USB
// charger.
TEST_F(BatterySaverControllerTest, USBCharging) {
  UpdatePowerStatus(GetActivationPercent() - 5, eight_hours_, false);
  EXPECT_TRUE(IsBatterySaverActive());

  // Attache a low-power charger and slowly charge, Battery Saver remains on.
  for (int i = -5; i <= 5; i++) {
    UpdatePowerStatus(GetActivationPercent() + i, eight_hours_, true, true);
    EXPECT_TRUE(IsBatterySaverActive());
  }
}

// Metrics always logged on enable.
void ExpectEnabledMetrics(base::HistogramTester& histogram_tester,
                          base::HistogramBase::Count32 enabled_count) {
  histogram_tester.ExpectTotalCount("Ash.BatterySaver.BatteryPercent.Enabled",
                                    enabled_count);
  histogram_tester.ExpectTotalCount("Ash.BatterySaver.TimeToEmpty.Enabled",
                                    enabled_count);
}

// Metrics logged on enable when enabled via settings.
void ExpectSettingsEnabledMetrics(
    base::HistogramTester& histogram_tester,
    base::HistogramBase::Count32 settings_enabled_count) {
  histogram_tester.ExpectTotalCount(
      "Ash.BatterySaver.BatteryPercent.EnabledSettings",
      settings_enabled_count);
  histogram_tester.ExpectTotalCount(
      "Ash.BatterySaver.TimeToEmpty.EnabledSettings", settings_enabled_count);
}

// Metrics always logged on disable.
void ExpectDisabledMetrics(base::HistogramTester& histogram_tester,
                           base::HistogramBase::Count32 disabled_count) {
  histogram_tester.ExpectTotalCount("Ash.BatterySaver.BatteryPercent.Disabled",
                                    disabled_count);
  histogram_tester.ExpectTotalCount("Ash.BatterySaver.TimeToEmpty.Disabled",
                                    disabled_count);
  histogram_tester.ExpectTotalCount("Ash.BatterySaver.Duration",
                                    disabled_count);
}

// Metrics logged on disable when enabled via notification.
void ExpectNotificationEnabledMetricsOnDisable(
    base::HistogramTester& histogram_tester,
    base::HistogramBase::Count32 notification_enabled_count) {
  histogram_tester.ExpectTotalCount(
      "Ash.BatterySaver.Duration.EnabledNotification",
      notification_enabled_count);
}

// Metrics logged on disable when enabled via settings.
void ExpectSettingsEnabledMetricsOnDisable(
    base::HistogramTester& histogram_tester,
    base::HistogramBase::Count32 settings_enabled_count) {
  histogram_tester.ExpectTotalCount("Ash.BatterySaver.Duration.EnabledSettings",
                                    settings_enabled_count);
}

// Metrics logged on disable when disabled via charging.
void ExpectChargingDisabledMetrics(
    base::HistogramTester& histogram_tester,
    base::HistogramBase::Count32 charging_disabled_count) {
  histogram_tester.ExpectTotalCount(
      "Ash.BatterySaver.Duration.DisabledCharging", charging_disabled_count);
}

// Metrics logged on disable when disabled via notification.
void ExpectNotificationDisabledMetrics(
    base::HistogramTester& histogram_tester,
    base::HistogramBase::Count32 notification_disabled_count) {
  histogram_tester.ExpectTotalCount(
      "Ash.BatterySaver.Duration.DisabledNotification",
      notification_disabled_count);
}

// Metrics logged on disable when disabled via settings.
void ExpectSettingsDisabledMetrics(
    base::HistogramTester& histogram_tester,
    base::HistogramBase::Count32 settings_disabled_count) {
  histogram_tester.ExpectTotalCount(
      "Ash.BatterySaver.BatteryPercent.DisabledSettings",
      settings_disabled_count);
  histogram_tester.ExpectTotalCount(
      "Ash.BatterySaver.TimeToEmpty.DisabledSettings", settings_disabled_count);
  histogram_tester.ExpectTotalCount(
      "Ash.BatterySaver.Duration.DisabledSettings", settings_disabled_count);
}

TEST_F(BatterySaverControllerTest, Metrics) {
  base::HistogramTester ht;

  // TimeToEmpty should have a value.
  UpdatePowerStatus(80.0, eight_hours_, false);

  // Enable with settings.
  ExpectEnabledMetrics(ht, 0);
  ExpectSettingsEnabledMetrics(ht, 0);
  battery_saver_controller()->SetState(
      true, BatterySaverController::UpdateReason::kSettings);
  ExpectEnabledMetrics(ht, 1);
  ExpectSettingsEnabledMetrics(ht, 1);

  // Disable with settings.
  ExpectDisabledMetrics(ht, 0);
  ExpectSettingsEnabledMetricsOnDisable(ht, 0);
  ExpectSettingsDisabledMetrics(ht, 0);
  battery_saver_controller()->SetState(
      false, BatterySaverController::UpdateReason::kSettings);
  ExpectDisabledMetrics(ht, 1);
  ExpectSettingsEnabledMetricsOnDisable(ht, 1);
  ExpectSettingsDisabledMetrics(ht, 1);

  // Enable with notification.
  ExpectEnabledMetrics(ht, 1);
  battery_saver_controller()->SetState(
      true, BatterySaverController::UpdateReason::kThreshold);
  ExpectEnabledMetrics(ht, 2);

  // Disable with notification.
  ExpectDisabledMetrics(ht, 1);
  ExpectNotificationEnabledMetricsOnDisable(ht, 0);
  ExpectNotificationDisabledMetrics(ht, 0);
  battery_saver_controller()->SetState(
      false, BatterySaverController::UpdateReason::kThreshold);
  ExpectDisabledMetrics(ht, 2);
  ExpectNotificationEnabledMetricsOnDisable(ht, 1);
  ExpectNotificationDisabledMetrics(ht, 1);

  // Enable again with notifications, just because we need it enabled to test
  // disabling with charging.
  ExpectEnabledMetrics(ht, 2);
  battery_saver_controller()->SetState(
      true, BatterySaverController::UpdateReason::kThreshold);
  ExpectEnabledMetrics(ht, 3);

  // Disable with charging.
  ExpectDisabledMetrics(ht, 2);
  ExpectNotificationEnabledMetricsOnDisable(ht, 1);
  ExpectChargingDisabledMetrics(ht, 0);
  battery_saver_controller()->SetState(
      false, BatterySaverController::UpdateReason::kCharging);
  ExpectDisabledMetrics(ht, 3);
  ExpectNotificationEnabledMetricsOnDisable(ht, 2);
  ExpectChargingDisabledMetrics(ht, 1);

  // Check that we didn't have any spurious metrics logged.
  ExpectEnabledMetrics(ht, 3);
  ExpectSettingsEnabledMetrics(ht, 1);
  ExpectSettingsEnabledMetricsOnDisable(ht, 1);
  ExpectNotificationDisabledMetrics(ht, 1);
  ExpectSettingsDisabledMetrics(ht, 1);
}

TEST_F(BatterySaverControllerTest, ShowDisableToast) {
  // Ensure there is no `ToastOverlay` being displayed at the start of the test.
  ToastOverlay* current_toast = GetCurrentToast();
  EXPECT_EQ(current_toast, nullptr);

  // Test Disabled Toast via Button.
  // Enable battery saver mode.
  battery_saver_controller()->SetState(
      true, BatterySaverController::UpdateReason::kThreshold);

  // There should be no `ToastOverlay` displayed when battery saver is enabled.
  current_toast = GetCurrentToast();
  EXPECT_EQ(current_toast, nullptr);

  // Disable battery saver mode via button.
  battery_saver_controller()->SetState(
      false, BatterySaverController::UpdateReason::kThreshold);

  // Check to see if a `ToastOverlay` was displayed, and that it's accurate.
  current_toast = GetCurrentToast();
  EXPECT_NE(current_toast, nullptr);
  EXPECT_EQ(
      current_toast->GetText(),
      l10n_util::GetStringUTF16(IDS_ASH_BATTERY_SAVER_DISABLED_TOAST_TEXT));
  DismissToast();

  // Test Disabled Toast via Charging.
  // Enable battery saver mode.
  battery_saver_controller()->SetState(
      true, BatterySaverController::UpdateReason::kThreshold);

  // There should be no `ToastOverlay` displayed when battery saver is enabled.
  current_toast = GetCurrentToast();
  EXPECT_EQ(current_toast, nullptr);

  // Disable battery saver mode via Charging.
  battery_saver_controller()->SetState(
      false, BatterySaverController::UpdateReason::kCharging);

  // Check to see if a `ToastOverlay` was displayed, and that it's accurate.
  current_toast = GetCurrentToast();
  EXPECT_NE(current_toast, nullptr);
  EXPECT_EQ(
      current_toast->GetText(),
      l10n_util::GetStringUTF16(IDS_ASH_BATTERY_SAVER_DISABLED_TOAST_TEXT));
  DismissToast();

  // Test Disabled Toast via Settings.
  // Reenable to test that toast doesn't appear when toggled via Settings.
  battery_saver_controller()->SetState(
      true, BatterySaverController::UpdateReason::kSettings);

  // Disable battery saver mode via Settings toggle.
  battery_saver_controller()->SetState(
      false, BatterySaverController::UpdateReason::kSettings);

  // Check there is still no toast since we disabled via Settings.
  current_toast = GetCurrentToast();
  EXPECT_EQ(current_toast, nullptr);
}

TEST_F(BatterySaverControllerTest, Allowed) {
  // Battery Saver is allowed by default.
  EXPECT_TRUE(IsBatterySaverAllowed());

  // If pref is managed and false, then Battery Saver is not allowed.
  local_state()->SetManagedPref(prefs::kPowerBatterySaver, base::Value(false));
  EXPECT_FALSE(IsBatterySaverAllowed());

  local_state()->RemoveManagedPref(prefs::kPowerBatterySaver);

  // If the experiment is off, Battery Saver is not allowed.
  scoped_feature_list_->Reset();
  scoped_feature_list_->InitAndDisableFeature(features::kBatterySaver);
  EXPECT_FALSE(IsBatterySaverAllowed());
}

TEST_F(BatterySaverControllerNotificationTest,
       ShowEnableToastAtCriticalPercentageForAutoEnable) {
  SetExperimentArm(features::kBSMAutoEnable);
  const int critical_percentage = Shell::Get()
                                      ->system_notification_controller()
                                      ->power_notification_controller()
                                      ->GetCriticalPowerPercentage();

  // Ensure there is no `ToastOverlay` being displayed at the start of the test.
  ToastOverlay* current_toast = GetCurrentToast();
  EXPECT_EQ(current_toast, nullptr);

  // Set the battery to a critical percentage.
  UpdatePowerStatus(critical_percentage, eight_hours_, /*charging=*/false);

  // The enabled toast should be displayed.
  current_toast = GetCurrentToast();
  EXPECT_NE(current_toast, nullptr);
  EXPECT_EQ(
      current_toast->GetText(),
      l10n_util::GetStringUTF16(IDS_ASH_BATTERY_SAVER_ENABLED_TOAST_TEXT));
  DismissToast();

  // Plug In AC Charger.
  UpdatePowerStatus(critical_percentage, eight_hours_, /*charging=*/true);

  // Toast should be 'Disabled' text.
  current_toast = GetCurrentToast();
  EXPECT_NE(current_toast, nullptr);
  EXPECT_EQ(
      current_toast->GetText(),
      l10n_util::GetStringUTF16(IDS_ASH_BATTERY_SAVER_DISABLED_TOAST_TEXT));
  DismissToast();
}

TEST_P(BatterySaverControllerNotificationTest, NotificationStateUpdatesOnUSB) {
  SetExperimentArm(features::kBatterySaverNotificationBehavior.Get());
  DismissNotification();

  // Start test with 100% battery, eight hours time remaining, not charging.
  UpdatePowerStatus(100, eight_hours_, /*charging=*/false);
  NotificationNotPresent();
  DismissNotification();

  // Battery read jumps (not smoothly) from above threshold to below threshold.
  UpdatePowerStatus(GetActivationPercent() - 1, eight_hours_,
                    /*charging=*/false);
  NotificationPresent();
  DismissNotification();
  EXPECT_TRUE(IsBatterySaverActive());

  // Simulate USB Plug-In, which detects as AC first, then USB.
  UpdatePowerStatus(GetActivationPercent() - 1, eight_hours_,
                    /*charging=*/true);
  EXPECT_FALSE(IsBatterySaverActive());
  UpdatePowerStatus(GetActivationPercent() - 1, eight_hours_,
                    /*charging=*/false, /*is_usb_charger=*/true);
  EXPECT_EQ(IsBatterySaverActive(),
            features::kBatterySaverNotificationBehavior.Get() ==
                features::kBSMAutoEnable);
  NotificationPresent();

  // Disable Battery Saver via Settings toggle.
  // This should cause an update in notification state, but not in notification.
  battery_saver_controller()->SetState(
      false, BatterySaverController::UpdateReason::kSettings);

  // Unplug USB Charger.
  UpdatePowerStatus(GetActivationPercent() - 1, eight_hours_,
                    /*charging=*/false, /*is_usb_charger=*/false);

  // If notification state was updated, then we should show a generic low power
  // notification.
  EXPECT_EQ(GetCurrentNotification()->title(),
            l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_LOW_BATTERY_TITLE));
  EXPECT_EQ(GetCurrentNotification()->buttons().size(), static_cast<ulong>(0));
}

TEST_P(BatterySaverControllerNotificationTest,
       ReenableOnUnplugBelowThresholds) {
  SetExperimentArm(GetParam());

  // Start the test at percent threshold with no charging.
  UpdatePowerStatus(GetActivationPercent(), eight_hours_, false);
  switch (features::kBatterySaverNotificationBehavior.Get()) {
    case features::kBSMAutoEnable:
      EXPECT_TRUE(IsBatterySaverActive());
      break;
    case features::kBSMOptIn:
      EXPECT_FALSE(IsBatterySaverActive());
      break;
    default:
      FAIL();
  }

  // Plug in the charger at percent threshold.
  UpdatePowerStatus(GetActivationPercent(), eight_hours_, true);
  EXPECT_FALSE(IsBatterySaverActive());

  // Unplug the charger, and expect BSM to stay on if we are in an auto-enable
  // state.
  UpdatePowerStatus(GetActivationPercent(), eight_hours_, false);
  switch (features::kBatterySaverNotificationBehavior.Get()) {
    case features::kBSMAutoEnable:
      EXPECT_TRUE(IsBatterySaverActive());
      break;
    case features::kBSMOptIn:
      EXPECT_FALSE(IsBatterySaverActive());
      break;
    default:
      FAIL();
  }
}

TEST_P(BatterySaverControllerNotificationTest,
       TestNotificationThresholdsForExperimentArms) {
  SetExperimentArm(GetParam());

  auto NotificationNotPresent = [&]() {
    EXPECT_EQ(GetCurrentNotification(), nullptr);
  };
  auto NotificationPresent = [&]() {
    EXPECT_NE(GetCurrentNotification(), nullptr);
  };

  // Start test with 100% battery, eight hours time remaining, not charging.
  UpdatePowerStatus(100, eight_hours_, true);
  DismissNotification();

  // Battery discharging but just above the activation %, battery saver should
  // be disabled.
  UpdatePowerStatus(GetActivationPercent() + 1, eight_hours_, false);
  EXPECT_FALSE(IsBatterySaverActive());
  NotificationNotPresent();

  // Battery read jumps (not smoothly) from above threshold to below threshold.
  UpdatePowerStatus(GetActivationPercent() - 1, eight_hours_, false);
  switch (features::kBatterySaverNotificationBehavior.Get()) {
    case features::kBSMAutoEnable:
      EXPECT_TRUE(IsBatterySaverActive());
      break;
    case features::kBSMOptIn:
      EXPECT_FALSE(IsBatterySaverActive());
      break;
    default:
      FAIL();
  }

  // Notification should appear regardless of battery saver state (so user can
  // opt-in/out).
  NotificationPresent();
  DismissNotification();

  // Check to make sure that the notification doesn't reappear after it's been
  // dismissed.
  UpdatePowerStatus(GetActivationPercent() - 2, eight_hours_, false);
  NotificationNotPresent();
}

TEST_P(BatterySaverControllerNotificationTest,
       NotificationReappearsAfterChargeThenDischarge) {
  SetExperimentArm(GetParam());

  // Start test with 100% battery, eight hours time remaining, not charging.
  UpdatePowerStatus(100, eight_hours_, true);
  DismissNotification();

  // Battery read jumps (not smoothly) from above threshold to below threshold.
  UpdatePowerStatus(GetActivationPercent() - 1, eight_hours_, false);

  // Notification for threshold should appear.
  NotificationPresent();
  DismissNotification();

  // Charging, battery goes above threshold.
  UpdatePowerStatus(GetActivationPercent() + 1, eight_hours_, true);
  NotificationNotPresent();

  // Discharging, battery goes below threshold.
  UpdatePowerStatus(GetActivationPercent() - 1, eight_hours_, false);

  // Notification should reappear.
  NotificationPresent();
  DismissNotification();
}

INSTANTIATE_TEST_SUITE_P(
    All,
    BatterySaverControllerNotificationTest,
    testing::Values(features::BatterySaverNotificationBehavior::kBSMAutoEnable,
                    features::BatterySaverNotificationBehavior::kBSMOptIn));

class BatterySaverControllerInitTest : public testing::Test {
 public:
  void SetUp() override {
    BatterySaverController::RegisterLocalStatePrefs(local_state_.registry());

    chromeos::PowerManagerClient::InitializeFake();
    power_manager_client_ = chromeos::FakePowerManagerClient::Get();

    PowerStatus::Initialize();
  }

  void TearDown() override {
    PowerStatus::Shutdown();
    power_manager_client_ = nullptr;
    chromeos::PowerManagerClient::Shutdown();
  }

 protected:
  void UpdatePowerPropertiesToDischarging(int battery_percent) {
    power_manager::PowerSupplyProperties proto;
    proto.set_battery_state(
        power_manager::PowerSupplyProperties_BatteryState_DISCHARGING);
    proto.set_external_power(
        power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED);
    proto.set_battery_percent(battery_percent);
    proto.set_is_calculating_battery_time(false);
    proto.set_battery_time_to_empty_sec(3600.0);
    power_manager_client_->UpdatePowerProperties(proto);
    base::RunLoop().RunUntilIdle();
  }

  base::test::SingleThreadTaskEnvironment task_environment_;
  TestingPrefServiceSimple local_state_;
  raw_ptr<chromeos::FakePowerManagerClient> power_manager_client_;
};

// Test that Battery Saver active state is preserved across restarts.
TEST_F(BatterySaverControllerInitTest, RestoreState) {
  EXPECT_FALSE(power_manager_client_->battery_saver_mode_enabled());

  // Disabled by default.
  {
    local_state_.ClearPref(prefs::kPowerBatterySaver);
    std::unique_ptr<BatterySaverController> controller =
        std::make_unique<BatterySaverController>(&local_state_);
    EXPECT_FALSE(power_manager_client_->battery_saver_mode_enabled());
  }

  // Restore disabled.
  {
    local_state_.SetBoolean(prefs::kPowerBatterySaver, false);
    std::unique_ptr<BatterySaverController> controller =
        std::make_unique<BatterySaverController>(&local_state_);
    EXPECT_FALSE(power_manager_client_->battery_saver_mode_enabled());
  }

  // Restore enabled.
  {
    local_state_.SetBoolean(prefs::kPowerBatterySaver, true);
    std::unique_ptr<BatterySaverController> controller =
        std::make_unique<BatterySaverController>(&local_state_);
    EXPECT_TRUE(power_manager_client_->battery_saver_mode_enabled());
  }
}

// Test that Battery Saver is disabled when charging when shut down.
TEST_F(BatterySaverControllerInitTest, DisableAfterChargingWhenOff) {
  base::HistogramTester ht;
  const int battery_percent = 80;
  local_state_.SetBoolean(prefs::kPowerBatterySaver, true);
  local_state_.SetInteger(prefs::kPowerBatterySaverPercent, battery_percent);

  // Set battery_percent above saved pref value to trigger charge detection.
  UpdatePowerPropertiesToDischarging(
      battery_percent +
      BatterySaverController::kBatterySaverSleepChargeThreshold);

  // Initialize BatterySaverController and check that battery saver is OFF.
  std::unique_ptr<BatterySaverController> controller =
      std::make_unique<BatterySaverController>(&local_state_);
  base::RunLoop().RunUntilIdle();

  EXPECT_FALSE(power_manager_client_->battery_saver_mode_enabled());
  EXPECT_FALSE(PowerStatus::Get()->IsBatterySaverActive());

  ExpectDisabledMetrics(ht, 1);
  ExpectChargingDisabledMetrics(ht, 1);
}

// Test that Battery Saver remains on after charging when shut down if the
// battery is low enough that it would be re-enabled.
TEST_F(BatterySaverControllerInitTest, EnableAfterChargingWhenOffAtLowBattery) {
  const int battery_percent = 5;
  local_state_.SetBoolean(prefs::kPowerBatterySaver, true);
  local_state_.SetInteger(prefs::kPowerBatterySaverPercent, battery_percent);

  // Set battery_percent above saved pref value to trigger charge detection.
  UpdatePowerPropertiesToDischarging(
      battery_percent +
      BatterySaverController::kBatterySaverSleepChargeThreshold);

  // Initialize BatterySaverController and check that battery saver is ON.
  std::unique_ptr<BatterySaverController> controller =
      std::make_unique<BatterySaverController>(&local_state_);
  base::RunLoop().RunUntilIdle();

  EXPECT_TRUE(power_manager_client_->battery_saver_mode_enabled());
  EXPECT_TRUE(PowerStatus::Get()->IsBatterySaverActive());
}

}  // namespace ash