// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/dbus/power/fake_power_manager_client.h"
#include "base/run_loop.h"
#include "base/test/task_environment.h"
#include "chromeos/dbus/power_manager/backlight.pb.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace chromeos {
namespace {
const double kInitialBatteryPercent = 85;
const double kUpdatedBatteryPercent = 70;
const power_manager::PowerSupplyProperties_BatteryState kInitialBatteryState =
power_manager::PowerSupplyProperties_BatteryState_DISCHARGING;
const power_manager::PowerSupplyProperties_ExternalPower kInitialExternalPower =
power_manager::PowerSupplyProperties_ExternalPower_USB;
class TestObserver : public PowerManagerClient::Observer {
public:
TestObserver() : num_power_changed_(0) {}
TestObserver(const TestObserver&) = delete;
TestObserver& operator=(const TestObserver&) = delete;
~TestObserver() override = default;
const power_manager::PowerSupplyProperties& props() const { return props_; }
int num_power_changed() const { return num_power_changed_; }
const power_manager::BatterySaverModeState& battery_saver_state() const {
return battery_saver_state_;
}
const power_manager::AmbientLightSensorChange&
last_ambient_light_sensor_change() const {
return last_ambient_light_sensor_change_;
}
const power_manager::AmbientLightSensorChange&
last_keyboard_ambient_light_sensor_change() const {
return last_keyboard_ambient_light_sensor_change_;
}
void ClearProps() { props_.Clear(); }
void PowerChanged(
const power_manager::PowerSupplyProperties& proto) override {
props_ = proto;
++num_power_changed_;
}
void BatterySaverModeStateChanged(
const power_manager::BatterySaverModeState& proto) override {
battery_saver_state_ = proto;
}
void AmbientLightSensorEnabledChanged(
const power_manager::AmbientLightSensorChange& change) override {
last_ambient_light_sensor_change_ = change;
}
void KeyboardAmbientLightSensorEnabledChanged(
const power_manager::AmbientLightSensorChange& change) override {
last_keyboard_ambient_light_sensor_change_ = change;
}
private:
int num_power_changed_;
power_manager::PowerSupplyProperties props_;
power_manager::BatterySaverModeState battery_saver_state_;
power_manager::AmbientLightSensorChange last_ambient_light_sensor_change_;
power_manager::AmbientLightSensorChange
last_keyboard_ambient_light_sensor_change_;
};
void SetTestProperties(power_manager::PowerSupplyProperties* props) {
props->set_battery_percent(kInitialBatteryPercent);
props->set_is_calculating_battery_time(true);
props->set_battery_state(kInitialBatteryState);
props->set_external_power(kInitialExternalPower);
}
} // namespace
TEST(FakePowerManagerClientTest, UpdatePowerPropertiesTest) {
// Checking to verify when UpdatePowerProperties is called,
// |props_| values are updated.
FakePowerManagerClient client;
power_manager::PowerSupplyProperties props;
SetTestProperties(&props);
client.UpdatePowerProperties(props);
EXPECT_EQ(kInitialBatteryPercent, client.GetLastStatus()->battery_percent());
EXPECT_TRUE(client.GetLastStatus()->is_calculating_battery_time());
EXPECT_EQ(kInitialBatteryState, client.GetLastStatus()->battery_state());
EXPECT_EQ(kInitialExternalPower, client.GetLastStatus()->external_power());
// Test if when the values are changed, the correct data is set in the
// FakePowerManagerClient.
props = *client.GetLastStatus();
props.set_battery_percent(kUpdatedBatteryPercent);
client.UpdatePowerProperties(props);
EXPECT_EQ(kUpdatedBatteryPercent, client.GetLastStatus()->battery_percent());
EXPECT_TRUE(client.GetLastStatus()->is_calculating_battery_time());
EXPECT_EQ(kInitialBatteryState, client.GetLastStatus()->battery_state());
EXPECT_EQ(kInitialExternalPower, client.GetLastStatus()->external_power());
}
TEST(FakePowerManagerClientTest, NotifyObserversTest) {
FakePowerManagerClient client;
TestObserver test_observer;
// Test adding observer.
client.AddObserver(&test_observer);
EXPECT_TRUE(client.HasObserver(&test_observer));
// Test if NotifyObservers() sends the correct values to |observer|.
// Check number of times NotifyObservers() is called.
power_manager::PowerSupplyProperties props;
SetTestProperties(&props);
client.UpdatePowerProperties(props);
EXPECT_EQ(kInitialBatteryPercent, test_observer.props().battery_percent());
EXPECT_TRUE(test_observer.props().is_calculating_battery_time());
EXPECT_EQ(kInitialBatteryState, test_observer.props().battery_state());
EXPECT_EQ(kInitialExternalPower, test_observer.props().external_power());
EXPECT_EQ(1, test_observer.num_power_changed());
// Test if RequestStatusUpdate() will propagate the data to the observer.
// Check number of times NotifyObservers is called.
// RequestStatusUpdate posts to the current message loop. This is
// necessary because we want to make sure that NotifyObservers() is
// called as a result of RequestStatusUpdate().
base::test::SingleThreadTaskEnvironment task_environment(
base::test::SingleThreadTaskEnvironment::MainThreadType::UI);
test_observer.ClearProps();
client.RequestStatusUpdate();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(kInitialBatteryPercent, test_observer.props().battery_percent());
EXPECT_TRUE(test_observer.props().is_calculating_battery_time());
EXPECT_EQ(kInitialBatteryState, test_observer.props().battery_state());
EXPECT_EQ(kInitialExternalPower, test_observer.props().external_power());
EXPECT_EQ(2, test_observer.num_power_changed());
// Check when values are changed, the correct values are propagated to the
// observer
props = *client.GetLastStatus();
props.set_battery_percent(kUpdatedBatteryPercent);
props.set_external_power(
power_manager::PowerSupplyProperties_ExternalPower_AC);
client.UpdatePowerProperties(props);
EXPECT_EQ(kUpdatedBatteryPercent, test_observer.props().battery_percent());
EXPECT_TRUE(test_observer.props().is_calculating_battery_time());
EXPECT_EQ(kInitialBatteryState, test_observer.props().battery_state());
EXPECT_EQ(power_manager::PowerSupplyProperties_ExternalPower_AC,
test_observer.props().external_power());
EXPECT_EQ(3, test_observer.num_power_changed());
// Test removing observer.
client.RemoveObserver(&test_observer);
EXPECT_FALSE(client.HasObserver(&test_observer));
}
TEST(FakePowerManagerClientTest, UpdatePowerPropertiesWithNullTest) {
// Checking to verify when UpdatePowerProperties is called,
// |props_| values are updated.
FakePowerManagerClient client;
power_manager::PowerSupplyProperties props;
SetTestProperties(&props);
client.UpdatePowerProperties(props);
ASSERT_TRUE(client.GetLastStatus().has_value());
EXPECT_EQ(kInitialBatteryPercent, client.GetLastStatus()->battery_percent());
EXPECT_TRUE(client.GetLastStatus()->is_calculating_battery_time());
EXPECT_EQ(kInitialBatteryState, client.GetLastStatus()->battery_state());
EXPECT_EQ(kInitialExternalPower, client.GetLastStatus()->external_power());
client.UpdatePowerProperties(std::nullopt);
EXPECT_FALSE(client.GetLastStatus().has_value());
}
TEST(FakePowerManagerClientTest,
UpdatePowerPropertiesWithNullWillNotNotifyObserversTest) {
FakePowerManagerClient client;
TestObserver test_observer;
// Test adding observer.
client.AddObserver(&test_observer);
EXPECT_TRUE(client.HasObserver(&test_observer));
// Test if NotifyObservers() sends the correct values to |observer|.
// Check number of times NotifyObservers() is called.
power_manager::PowerSupplyProperties props;
SetTestProperties(&props);
client.UpdatePowerProperties(props);
EXPECT_EQ(1, test_observer.num_power_changed());
EXPECT_EQ(kInitialBatteryPercent, test_observer.props().battery_percent());
EXPECT_TRUE(test_observer.props().is_calculating_battery_time());
EXPECT_EQ(kInitialBatteryState, test_observer.props().battery_state());
EXPECT_EQ(kInitialExternalPower, test_observer.props().external_power());
// Check when update power properties with null,
// the observer isn't notified and the props from observer doesn't change.
client.UpdatePowerProperties(std::nullopt);
EXPECT_EQ(1, test_observer.num_power_changed());
EXPECT_EQ(kInitialBatteryPercent, test_observer.props().battery_percent());
EXPECT_TRUE(test_observer.props().is_calculating_battery_time());
EXPECT_EQ(kInitialBatteryState, test_observer.props().battery_state());
EXPECT_EQ(kInitialExternalPower, test_observer.props().external_power());
}
// Test that observers are notified asynchronously of battery saver state
// updates.
TEST(FakePowerManagerClientTest, BatterySaverState) {
base::test::SingleThreadTaskEnvironment task_environment(
base::test::SingleThreadTaskEnvironment::MainThreadType::UI);
FakePowerManagerClient client;
TestObserver test_observer;
client.AddObserver(&test_observer);
EXPECT_FALSE(test_observer.battery_saver_state().has_enabled());
// Turn battery saver on, and check that observers are notified
// asynchronously.
{
power_manager::SetBatterySaverModeStateRequest request;
request.set_enabled(true);
client.SetBatterySaverModeState(request);
// Battery saver should not be enabled synchronously, since the real client
// waits for a response from Power Manager.
EXPECT_FALSE(test_observer.battery_saver_state().has_enabled());
base::RunLoop().RunUntilIdle();
// Should be on now.
EXPECT_TRUE(test_observer.battery_saver_state().has_enabled());
EXPECT_TRUE(test_observer.battery_saver_state().enabled());
}
// Verify GetBatterySaverModeState is on and asynchronous.
{
bool called = false;
client.GetBatterySaverModeState(base::BindOnce(
[](std::reference_wrapper<bool> called_ref,
std::optional<power_manager::BatterySaverModeState> state) {
EXPECT_TRUE(state.has_value());
EXPECT_TRUE(state->has_enabled());
EXPECT_TRUE(state->enabled());
called_ref.get() = true;
},
std::ref(called)));
// Result should be asynchronous.
EXPECT_FALSE(called);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(called);
}
// Turn battery saver off, and check that observers are notified
// asynchronously.
{
power_manager::SetBatterySaverModeStateRequest request;
request.set_enabled(false);
client.SetBatterySaverModeState(request);
// Again, make sure response is async by checking for stale values.
EXPECT_TRUE(test_observer.battery_saver_state().has_enabled());
EXPECT_TRUE(test_observer.battery_saver_state().enabled());
base::RunLoop().RunUntilIdle();
// Should be off now.
EXPECT_TRUE(test_observer.battery_saver_state().has_enabled());
EXPECT_FALSE(test_observer.battery_saver_state().enabled());
}
// Verify GetBatterySaverModeState is off and asynchronous.
{
bool called = false;
client.GetBatterySaverModeState(base::BindOnce(
[](std::reference_wrapper<bool> called_ref,
std::optional<power_manager::BatterySaverModeState> state) {
EXPECT_TRUE(state.has_value());
EXPECT_TRUE(state->has_enabled());
EXPECT_FALSE(state->enabled());
called_ref.get() = true;
},
std::ref(called)));
// Result should be asynchronous.
EXPECT_FALSE(called);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(called);
}
}
// Test that observers are notified asynchronously when the Ambient Light Sensor
// status changes.
TEST(FakePowerManagerClientTest, AmbientLightSensorEnabled) {
base::test::SingleThreadTaskEnvironment task_environment(
base::test::SingleThreadTaskEnvironment::MainThreadType::UI);
FakePowerManagerClient client;
TestObserver test_observer;
client.AddObserver(&test_observer);
// The Ambient Light Sensor is enabled by default.
EXPECT_FALSE(
test_observer.last_ambient_light_sensor_change().has_sensor_enabled());
EXPECT_FALSE(test_observer.last_ambient_light_sensor_change().has_cause());
// Turn the Ambient Light Sensor off, and check that observers are notified
// asynchronously.
power_manager::SetAmbientLightSensorEnabledRequest set_als_request;
set_als_request.set_sensor_enabled(false);
client.SetAmbientLightSensorEnabled(set_als_request);
// The Ambient Light Sensor should not be disabled synchronously, since the
// real client waits for a response from Power Manager.
EXPECT_FALSE(
test_observer.last_ambient_light_sensor_change().has_sensor_enabled());
EXPECT_FALSE(test_observer.last_ambient_light_sensor_change().has_cause());
base::RunLoop().RunUntilIdle();
// The Ambient Light Sensor should be disabled now.
EXPECT_TRUE(
test_observer.last_ambient_light_sensor_change().has_sensor_enabled());
EXPECT_FALSE(
test_observer.last_ambient_light_sensor_change().sensor_enabled());
// The change cause should be USER_REQUEST_SETTINGS_APP because the change was
// triggered via the PowerManagerClient function.
EXPECT_TRUE(test_observer.last_ambient_light_sensor_change().has_cause());
EXPECT_EQ(
test_observer.last_ambient_light_sensor_change().cause(),
power_manager::AmbientLightSensorChange_Cause_USER_REQUEST_SETTINGS_APP);
// Turn the Ambient Light Sensor on, and check that observers are notified
// asynchronously.
set_als_request.set_sensor_enabled(true);
client.SetAmbientLightSensorEnabled(set_als_request);
// The Ambient Light Sensor should not be enabled synchronously, since the
// real client waits for a response from Power Manager.
EXPECT_TRUE(
test_observer.last_ambient_light_sensor_change().has_sensor_enabled());
EXPECT_FALSE(
test_observer.last_ambient_light_sensor_change().sensor_enabled());
base::RunLoop().RunUntilIdle();
// The Ambient Light Sensor should be enabled now.
EXPECT_TRUE(
test_observer.last_ambient_light_sensor_change().sensor_enabled());
// The cause should be the same as before.
EXPECT_TRUE(test_observer.last_ambient_light_sensor_change().has_cause());
EXPECT_EQ(
test_observer.last_ambient_light_sensor_change().cause(),
power_manager::AmbientLightSensorChange_Cause_USER_REQUEST_SETTINGS_APP);
}
// Test that observers are notified asynchronously when the Keyboard Ambient
// Light Sensor status changes.
TEST(FakePowerManagerClientTest, KeyboardAmbientLightSensorEnabled) {
base::test::SingleThreadTaskEnvironment task_environment(
base::test::SingleThreadTaskEnvironment::MainThreadType::UI);
FakePowerManagerClient client;
TestObserver test_observer;
client.AddObserver(&test_observer);
// The Keyboard Ambient Light Sensor is enabled by default.
EXPECT_FALSE(test_observer.last_keyboard_ambient_light_sensor_change()
.has_sensor_enabled());
EXPECT_FALSE(
test_observer.last_keyboard_ambient_light_sensor_change().has_cause());
// Turn the Keyboard Ambient Light Sensor off, and check that observers are
// notified asynchronously.
power_manager::SetAmbientLightSensorEnabledRequest set_als_request;
set_als_request.set_sensor_enabled(false);
client.SetKeyboardAmbientLightSensorEnabled(set_als_request);
// The Keyboard Ambient Light Sensor should not be disabled synchronously,
// since the real client waits for a response from Power Manager.
EXPECT_FALSE(test_observer.last_keyboard_ambient_light_sensor_change()
.has_sensor_enabled());
EXPECT_FALSE(
test_observer.last_keyboard_ambient_light_sensor_change().has_cause());
base::RunLoop().RunUntilIdle();
// The Keyboard Ambient Light Sensor should be disabled now.
EXPECT_TRUE(test_observer.last_keyboard_ambient_light_sensor_change()
.has_sensor_enabled());
EXPECT_FALSE(test_observer.last_keyboard_ambient_light_sensor_change()
.sensor_enabled());
// The change cause should be USER_REQUEST_SETTINGS_APP because the change was
// triggered via the PowerManagerClient function.
EXPECT_TRUE(
test_observer.last_keyboard_ambient_light_sensor_change().has_cause());
EXPECT_EQ(
test_observer.last_keyboard_ambient_light_sensor_change().cause(),
power_manager::AmbientLightSensorChange_Cause_USER_REQUEST_SETTINGS_APP);
// Turn the Keyboard Ambient Light Sensor on, and check that observers are
// notified asynchronously.
set_als_request.set_sensor_enabled(true);
client.SetKeyboardAmbientLightSensorEnabled(set_als_request);
// The Keyboard Ambient Light Sensor should not be enabled synchronously,
// since the real client waits for a response from Power Manager.
EXPECT_TRUE(test_observer.last_keyboard_ambient_light_sensor_change()
.has_sensor_enabled());
EXPECT_FALSE(test_observer.last_keyboard_ambient_light_sensor_change()
.sensor_enabled());
base::RunLoop().RunUntilIdle();
// The Keyboard Ambient Light Sensor should be enabled now.
EXPECT_TRUE(test_observer.last_keyboard_ambient_light_sensor_change()
.sensor_enabled());
// The cause should be the same as before.
EXPECT_TRUE(
test_observer.last_keyboard_ambient_light_sensor_change().has_cause());
EXPECT_EQ(
test_observer.last_keyboard_ambient_light_sensor_change().cause(),
power_manager::AmbientLightSensorChange_Cause_USER_REQUEST_SETTINGS_APP);
}
// Test that GetAmbientLightSensorEnabled works correctly.
TEST(FakePowerManagerClientTest, GetAmbientLightSensorEnabled) {
base::test::SingleThreadTaskEnvironment task_environment(
base::test::SingleThreadTaskEnvironment::MainThreadType::UI);
FakePowerManagerClient client;
{
power_manager::SetAmbientLightSensorEnabledRequest set_als_request;
set_als_request.set_sensor_enabled(true);
client.SetAmbientLightSensorEnabled(set_als_request);
bool called = false;
client.GetAmbientLightSensorEnabled(base::BindOnce(
[](std::reference_wrapper<bool> called_ref,
std::optional<bool> is_ambient_light_sensor_enabled) {
// The callback should be called with a value indicating that the
// ambient light sensor is enabled.
EXPECT_TRUE(is_ambient_light_sensor_enabled.value());
// Indicate that this function was called.
called_ref.get() = true;
},
std::ref(called)));
// Result should be asynchronous.
EXPECT_FALSE(called);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(called);
}
{
power_manager::SetAmbientLightSensorEnabledRequest set_als_request;
set_als_request.set_sensor_enabled(false);
client.SetAmbientLightSensorEnabled(set_als_request);
bool called = false;
client.GetAmbientLightSensorEnabled(base::BindOnce(
[](std::reference_wrapper<bool> called_ref,
std::optional<bool> is_ambient_light_sensor_enabled) {
// The callback should be called with a value indicating that the
// ambient light sensor is not enabled.
EXPECT_FALSE(is_ambient_light_sensor_enabled.value());
// Indicate that this function was called.
called_ref.get() = true;
},
std::ref(called)));
// Result should be asynchronous.
EXPECT_FALSE(called);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(called);
}
}
} // namespace chromeos
Codebase Browser
chromium