blob: 68e28acb5ec3639d59a35d63af09518a069c7616 [file] [log] [blame]
// Copyright 2014 The Chromium 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 "device/battery/battery_status_manager_linux.h"
#include <limits>
#include <list>
#include <string>
#include "base/bind.h"
#include "base/single_thread_task_runner.h"
#include "base/synchronization/waitable_event.h"
#include "base/threading/thread.h"
#include "dbus/mock_bus.h"
#include "dbus/mock_object_proxy.h"
#include "dbus/object_path.h"
#include "dbus/property.h"
#include "device/battery/battery_status_manager_linux-inl.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using testing::_;
using testing::Invoke;
using testing::NiceMock;
using testing::Return;
using testing::Unused;
namespace device {
namespace {
const char kUPowerDeviceACLinePath[] =
"/org/freedesktop/UPower/devices/line_power_AC";
const char kUPowerDeviceBattery0Path[] =
"/org/freedesktop/UPower/devices/battery_BAT0";
const char kUPowerDeviceBattery1Path[] =
"/org/freedesktop/UPower/devices/battery_BAT1";
const char kUPowerDisplayDevicePath[] =
"/org/freedesktop/UPower/devices/DisplayDevice";
class MockUPowerObject {
public:
MockUPowerObject() {}
void ConnectToSignal(
const std::string& interface_name,
const std::string& signal_name,
dbus::ObjectProxy::SignalCallback signal_callback,
dbus::ObjectProxy::OnConnectedCallback on_connected_callback);
dbus::Response* CreateCallMethodResponse(dbus::MethodCall* method_call,
Unused);
void SignalDeviceAdded(const std::string& added_device_path);
void SignalDeviceRemoved(const std::string& removed_device_path);
scoped_refptr<dbus::MockObjectProxy> proxy;
dbus::ObjectProxy::SignalCallback signal_callback_device_added;
dbus::ObjectProxy::SignalCallback signal_callback_device_changed;
dbus::ObjectProxy::SignalCallback signal_callback_device_removed;
std::string daemon_version;
std::list<std::string> devices;
std::string display_device;
private:
DISALLOW_COPY_AND_ASSIGN(MockUPowerObject);
};
void MockUPowerObject::ConnectToSignal(
const std::string& interface_name,
const std::string& signal_name,
dbus::ObjectProxy::SignalCallback signal_callback,
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) {
bool on_connected_success = true;
if (interface_name == kUPowerInterfaceName) {
if (signal_name == kUPowerSignalDeviceAdded)
signal_callback_device_added = signal_callback;
else if (signal_name == kUPowerSignalDeviceRemoved)
signal_callback_device_removed = signal_callback;
else
on_connected_success = false;
} else {
on_connected_success = false;
}
if (!on_connected_success) {
LOG(WARNING) << "MockUPowerObject::" << __FUNCTION__
<< " Unexpected interface=" << interface_name
<< ", signal=" << signal_name;
}
on_connected_callback.Run(interface_name, signal_name, on_connected_success);
}
dbus::Response* MockUPowerObject::CreateCallMethodResponse(
dbus::MethodCall* method_call,
Unused) {
if (method_call->GetInterface() == kUPowerInterfaceName) {
if (method_call->GetMember() == kUPowerMethodEnumerateDevices) {
std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty();
dbus::MessageWriter writer(response.get());
dbus::MessageWriter array_writer(nullptr);
writer.OpenArray("o", &array_writer);
for (const auto& device : devices)
array_writer.AppendObjectPath(dbus::ObjectPath(device));
writer.CloseContainer(&array_writer);
return response.release();
} else if (method_call->GetMember() == kUPowerMethodGetDisplayDevice) {
std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty();
if (!display_device.empty()) {
dbus::MessageWriter writer(response.get());
writer.AppendObjectPath(dbus::ObjectPath(display_device));
}
return response.release();
}
} else if (method_call->GetInterface() == dbus::kPropertiesInterface) {
std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty();
dbus::MessageWriter writer(response.get());
if (method_call->GetMember() == dbus::kPropertiesGet) {
dbus::MessageReader reader(method_call);
std::string interface_name;
std::string property_name;
if (reader.PopString(&interface_name) &&
reader.PopString(&property_name) &&
property_name == kUPowerPropertyDaemonVersion) {
writer.AppendVariantOfString(daemon_version);
return response.release();
}
} else if (method_call->GetMember() == dbus::kPropertiesGetAll) {
dbus::MessageWriter array_writer(nullptr);
dbus::MessageWriter dict_entry_writer(nullptr);
writer.OpenArray("{sv}", &array_writer);
array_writer.OpenDictEntry(&dict_entry_writer);
dict_entry_writer.AppendString(kUPowerPropertyDaemonVersion);
dict_entry_writer.AppendVariantOfString(daemon_version);
array_writer.CloseContainer(&dict_entry_writer);
writer.CloseContainer(&array_writer);
return response.release();
}
}
LOG(ERROR) << "Unexpected method call: " << method_call->ToString();
return nullptr;
}
void MockUPowerObject::SignalDeviceAdded(const std::string& added_device_path) {
dbus::Signal signal(kUPowerInterfaceName, kUPowerSignalDeviceAdded);
signal.SetPath(proxy->object_path());
dbus::MessageWriter writer(&signal);
writer.AppendObjectPath(dbus::ObjectPath(added_device_path));
signal_callback_device_added.Run(&signal);
}
void MockUPowerObject::SignalDeviceRemoved(
const std::string& removed_device_path) {
dbus::Signal signal(kUPowerInterfaceName, kUPowerSignalDeviceRemoved);
signal.SetPath(proxy->object_path());
dbus::MessageWriter writer(&signal);
writer.AppendObjectPath(dbus::ObjectPath(removed_device_path));
signal_callback_device_removed.Run(&signal);
}
struct MockBatteryProperties {
bool is_present = true;
double percentage = 100;
uint32_t state = UPowerDeviceState::UPOWER_DEVICE_STATE_UNKNOWN;
int64_t time_to_empty = 0;
int64_t time_to_full = 0;
uint32_t type = UPowerDeviceType::UPOWER_DEVICE_TYPE_BATTERY;
};
class MockBatteryObject {
public:
MockBatteryObject(dbus::Bus* bus,
const std::string& object_path,
MockBatteryProperties* properties);
void ConnectToSignal(
const std::string& interface_name,
const std::string& signal_name,
dbus::ObjectProxy::SignalCallback signal_callback,
dbus::ObjectProxy::OnConnectedCallback on_connected_callback);
dbus::Response* CreateCallMethodResponse(dbus::MethodCall* method_call,
Unused);
MockBatteryObject& ExpectConnectToSignalChanged();
MockBatteryObject& ExpectConnectToSignalPropertyChanged();
void SignalChanged();
void SignalPropertyChanged(const std::string& property_name);
scoped_refptr<dbus::MockObjectProxy> proxy;
MockBatteryProperties* properties;
dbus::ObjectProxy::SignalCallback signal_callback_changed;
dbus::ObjectProxy::SignalCallback signal_callback_properties_changed;
private:
void AppendPropertyToWriter(dbus::MessageWriter* writer,
const std::string& property_name);
void AppendAllPropertiesToWriter(dbus::MessageWriter* writer);
DISALLOW_COPY_AND_ASSIGN(MockBatteryObject);
};
MockBatteryObject::MockBatteryObject(dbus::Bus* bus,
const std::string& object_path,
MockBatteryProperties* properties)
: proxy(new NiceMock<dbus::MockObjectProxy>(bus,
kUPowerServiceName,
dbus::ObjectPath(object_path))),
properties(properties) {}
void MockBatteryObject::ConnectToSignal(
const std::string& interface_name,
const std::string& signal_name,
dbus::ObjectProxy::SignalCallback signal_callback,
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) {
bool on_connected_success = true;
if (interface_name == kUPowerDeviceInterfaceName &&
signal_name == kUPowerDeviceSignalChanged)
signal_callback_changed = signal_callback;
else if (interface_name == dbus::kPropertiesInterface &&
signal_name == dbus::kPropertiesChanged)
signal_callback_properties_changed = signal_callback;
else
on_connected_success = false;
if (!on_connected_success) {
LOG(WARNING) << "MockBatteryObject::" << __FUNCTION__
<< " Unexpected interface=" << interface_name
<< ", signal=" << signal_name;
}
on_connected_callback.Run(interface_name, signal_name, on_connected_success);
}
dbus::Response* MockBatteryObject::CreateCallMethodResponse(
dbus::MethodCall* method_call,
Unused) {
if (method_call->GetInterface() == dbus::kPropertiesInterface) {
if (method_call->GetMember() == dbus::kPropertiesGet) {
if (!properties)
return nullptr;
dbus::MessageReader reader(method_call);
std::string interface_name;
std::string property_name;
if (reader.PopString(&interface_name) &&
reader.PopString(&property_name)) {
std::unique_ptr<dbus::Response> response =
dbus::Response::CreateEmpty();
dbus::MessageWriter writer(response.get());
AppendPropertyToWriter(&writer, property_name);
return response.release();
}
} else if (method_call->GetMember() == dbus::kPropertiesGetAll) {
if (!properties)
return nullptr;
std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty();
dbus::MessageWriter writer(response.get());
AppendAllPropertiesToWriter(&writer);
return response.release();
}
}
LOG(ERROR) << "Unexpected method call: " << method_call->ToString();
return nullptr;
}
MockBatteryObject& MockBatteryObject::ExpectConnectToSignalChanged() {
EXPECT_CALL(*proxy.get(), ConnectToSignal(kUPowerDeviceInterfaceName,
kUPowerDeviceSignalChanged, _, _))
.WillOnce(Invoke(this, &MockBatteryObject::ConnectToSignal));
return *this;
}
MockBatteryObject& MockBatteryObject::ExpectConnectToSignalPropertyChanged() {
EXPECT_CALL(*proxy.get(), ConnectToSignal(dbus::kPropertiesInterface,
dbus::kPropertiesChanged, _, _))
.WillOnce(Invoke(this, &MockBatteryObject::ConnectToSignal));
return *this;
}
void MockBatteryObject::SignalChanged() {
dbus::Signal signal(kUPowerInterfaceName, kUPowerDeviceSignalChanged);
signal.SetPath(proxy->object_path());
dbus::MessageWriter writer(&signal);
writer.AppendString(kUPowerDeviceInterfaceName);
signal_callback_changed.Run(&signal);
}
void MockBatteryObject::SignalPropertyChanged(
const std::string& property_name) {
dbus::Signal signal(dbus::kPropertiesInterface, dbus::kPropertiesChanged);
signal.SetPath(proxy->object_path());
dbus::MessageWriter writer(&signal);
writer.AppendString(kUPowerDeviceInterfaceName);
// Dictionary {sv} of property-name => new value:
dbus::MessageWriter array_writer(nullptr);
writer.OpenArray("{sv}", &array_writer);
writer.CloseContainer(&array_writer);
// Array of invalidated properties:
writer.OpenArray("s", &array_writer);
array_writer.AppendString(property_name);
writer.CloseContainer(&array_writer);
signal_callback_properties_changed.Run(&signal);
}
void MockBatteryObject::AppendPropertyToWriter(
dbus::MessageWriter* writer,
const std::string& property_name) {
if (property_name == kUPowerDevicePropertyIsPresent)
writer->AppendVariantOfBool(properties->is_present);
else if (property_name == kUPowerDevicePropertyPercentage)
writer->AppendVariantOfDouble(properties->percentage);
else if (property_name == kUPowerDevicePropertyState)
writer->AppendVariantOfUint32(properties->state);
else if (property_name == kUPowerDevicePropertyTimeToEmpty)
writer->AppendVariantOfInt64(properties->time_to_empty);
else if (property_name == kUPowerDevicePropertyTimeToFull)
writer->AppendVariantOfInt64(properties->time_to_full);
else if (property_name == kUPowerDevicePropertyType)
writer->AppendVariantOfUint32(properties->type);
else
LOG(WARNING) << __FUNCTION__ << " unknown property: " << property_name;
}
void MockBatteryObject::AppendAllPropertiesToWriter(
dbus::MessageWriter* writer) {
dbus::MessageWriter array_writer(nullptr);
dbus::MessageWriter dict_entry_writer(nullptr);
writer->OpenArray("{sv}", &array_writer);
for (auto property_name :
{kUPowerDevicePropertyIsPresent, kUPowerDevicePropertyState,
kUPowerDevicePropertyTimeToEmpty, kUPowerDevicePropertyTimeToFull,
kUPowerDevicePropertyType}) {
array_writer.OpenDictEntry(&dict_entry_writer);
dict_entry_writer.AppendString(property_name);
AppendPropertyToWriter(&dict_entry_writer, property_name);
array_writer.CloseContainer(&dict_entry_writer);
}
writer->CloseContainer(&array_writer);
}
} // namespace
class BatteryStatusManagerLinuxTest : public testing::Test {
public:
BatteryStatusManagerLinuxTest() {}
void SetUp() override;
MockBatteryObject& SetUpDisplayDeviceProxy(MockBatteryProperties* properties);
void AddDevicePath(const std::string& object_path);
void PushFrontDevicePath(const std::string& object_path);
MockBatteryObject& AddDeviceProxy(const std::string& object_path,
MockBatteryProperties* properties);
MockBatteryObject& PushFrontDeviceProxy(const std::string& object_path,
MockBatteryProperties* properties);
void ExpectGetObjectProxy(const std::string& object_path,
MockBatteryObject* mock_object);
void ExpectGetObjectProxy(const std::string& object_path,
dbus::ObjectProxy* object_proxy);
void DeviceSignalChanged(MockBatteryObject* device);
void DeviceSignalPropertyChanged(MockBatteryObject* device,
const std::string& property_name);
void UPowerSignalDeviceAdded(const std::string& device_path);
void UPowerSignalDeviceRemoved(const std::string& device_path);
void StartBatteryStatusManagerLinux();
int count_battery_updates() const { return count_battery_updates_; }
const BatteryStatus& last_battery_status() const { return last_status_; }
protected:
scoped_refptr<dbus::MockBus> mock_bus_;
MockUPowerObject mock_upower_;
std::unique_ptr<MockBatteryObject> mock_display_device_;
std::list<std::unique_ptr<MockBatteryObject>> mock_battery_devices_;
private:
std::unique_ptr<MockBatteryObject> CreateMockBatteryObject(
const std::string& object_path,
MockBatteryProperties* properties);
void BatteryUpdateCallback(const BatteryStatus& status);
void SyncWithNotifierThread();
std::unique_ptr<BatteryStatusManagerLinux> manager_;
int count_battery_updates_ = 0;
BatteryStatus last_status_;
DISALLOW_COPY_AND_ASSIGN(BatteryStatusManagerLinuxTest);
};
void BatteryStatusManagerLinuxTest::SetUp() {
dbus::Bus::Options options;
options.bus_type = dbus::Bus::SYSTEM;
options.connection_type = dbus::Bus::PRIVATE;
mock_bus_ = new NiceMock<dbus::MockBus>(options);
mock_upower_.proxy = new NiceMock<dbus::MockObjectProxy>(
mock_bus_.get(), kUPowerServiceName, dbus::ObjectPath(kUPowerPath));
ExpectGetObjectProxy(kUPowerPath, mock_upower_.proxy.get());
EXPECT_CALL(*mock_upower_.proxy.get(), MockCallMethodAndBlock(_, _))
.WillRepeatedly(
Invoke(&mock_upower_, &MockUPowerObject::CreateCallMethodResponse));
EXPECT_CALL(
*mock_upower_.proxy.get(),
ConnectToSignal(kUPowerInterfaceName, kUPowerSignalDeviceAdded, _, _))
.WillOnce(Invoke(&mock_upower_, &MockUPowerObject::ConnectToSignal));
EXPECT_CALL(
*mock_upower_.proxy.get(),
ConnectToSignal(kUPowerInterfaceName, kUPowerSignalDeviceRemoved, _, _))
.WillOnce(Invoke(&mock_upower_, &MockUPowerObject::ConnectToSignal));
}
MockBatteryObject& BatteryStatusManagerLinuxTest::SetUpDisplayDeviceProxy(
MockBatteryProperties* properties) {
mock_upower_.display_device = kUPowerDisplayDevicePath;
mock_display_device_ =
CreateMockBatteryObject(mock_upower_.display_device, properties);
return *mock_display_device_.get();
}
void BatteryStatusManagerLinuxTest::AddDevicePath(
const std::string& object_path) {
mock_upower_.devices.push_back(object_path);
}
void BatteryStatusManagerLinuxTest::PushFrontDevicePath(
const std::string& object_path) {
mock_upower_.devices.push_front(object_path);
}
MockBatteryObject& BatteryStatusManagerLinuxTest::AddDeviceProxy(
const std::string& object_path,
MockBatteryProperties* properties) {
AddDevicePath(object_path);
mock_battery_devices_.push_back(
CreateMockBatteryObject(object_path, properties));
return *mock_battery_devices_.back().get();
}
MockBatteryObject& BatteryStatusManagerLinuxTest::PushFrontDeviceProxy(
const std::string& object_path,
MockBatteryProperties* properties) {
PushFrontDevicePath(object_path);
mock_battery_devices_.push_front(
CreateMockBatteryObject(object_path, properties));
return *mock_battery_devices_.front().get();
}
void BatteryStatusManagerLinuxTest::ExpectGetObjectProxy(
const std::string& object_path,
MockBatteryObject* mock_object) {
ExpectGetObjectProxy(object_path, mock_object->proxy.get());
}
void BatteryStatusManagerLinuxTest::ExpectGetObjectProxy(
const std::string& object_path,
dbus::ObjectProxy* object_proxy) {
EXPECT_CALL(*mock_bus_.get(),
GetObjectProxy(kUPowerServiceName, dbus::ObjectPath(object_path)))
.WillOnce(Return(object_proxy));
}
void BatteryStatusManagerLinuxTest::DeviceSignalChanged(
MockBatteryObject* device) {
manager_->GetNotifierThreadForTesting()->task_runner()->PostTask(
FROM_HERE,
base::Bind(&MockBatteryObject::SignalChanged, base::Unretained(device)));
SyncWithNotifierThread();
}
void BatteryStatusManagerLinuxTest::DeviceSignalPropertyChanged(
MockBatteryObject* device,
const std::string& property_name) {
manager_->GetNotifierThreadForTesting()->task_runner()->PostTask(
FROM_HERE, base::Bind(&MockBatteryObject::SignalPropertyChanged,
base::Unretained(device), property_name));
SyncWithNotifierThread();
}
void BatteryStatusManagerLinuxTest::UPowerSignalDeviceAdded(
const std::string& device_path) {
ASSERT_FALSE(mock_upower_.signal_callback_device_added.is_null());
manager_->GetNotifierThreadForTesting()->task_runner()->PostTask(
FROM_HERE, base::Bind(&MockUPowerObject::SignalDeviceAdded,
base::Unretained(&mock_upower_), device_path));
SyncWithNotifierThread();
}
void BatteryStatusManagerLinuxTest::UPowerSignalDeviceRemoved(
const std::string& device_path) {
ASSERT_FALSE(mock_upower_.signal_callback_device_removed.is_null());
manager_->GetNotifierThreadForTesting()->task_runner()->PostTask(
FROM_HERE, base::Bind(&MockUPowerObject::SignalDeviceRemoved,
base::Unretained(&mock_upower_), device_path));
SyncWithNotifierThread();
}
void BatteryStatusManagerLinuxTest::StartBatteryStatusManagerLinux() {
manager_ = BatteryStatusManagerLinux::CreateForTesting(
base::Bind(&BatteryStatusManagerLinuxTest::BatteryUpdateCallback,
base::Unretained(this)),
mock_bus_.get());
manager_->StartListeningBatteryChange();
SyncWithNotifierThread();
}
std::unique_ptr<MockBatteryObject>
BatteryStatusManagerLinuxTest::CreateMockBatteryObject(
const std::string& object_path,
MockBatteryProperties* properties) {
std::unique_ptr<MockBatteryObject> mock_object(
new MockBatteryObject(mock_bus_.get(), object_path, properties));
ExpectGetObjectProxy(object_path, mock_object.get());
EXPECT_CALL(*mock_object->proxy.get(), MockCallMethodAndBlock(_, _))
.WillRepeatedly(Invoke(mock_object.get(),
&MockBatteryObject::CreateCallMethodResponse));
return mock_object;
}
void BatteryStatusManagerLinuxTest::BatteryUpdateCallback(
const BatteryStatus& status) {
++count_battery_updates_;
last_status_ = status;
}
void BatteryStatusManagerLinuxTest::SyncWithNotifierThread() {
ASSERT_TRUE(manager_ != nullptr);
base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
manager_->GetNotifierThreadForTesting()->task_runner()->PostTask(
FROM_HERE,
base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event)));
event.Wait();
}
TEST_F(BatteryStatusManagerLinuxTest, NoBattery) {
BatteryStatus default_status;
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_EQ(default_status.charging, status.charging);
EXPECT_EQ(default_status.charging_time, status.charging_time);
EXPECT_EQ(default_status.discharging_time, status.discharging_time);
EXPECT_EQ(default_status.level, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, ChargingHalfFull) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.percentage = 50;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_TRUE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(0.5, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, ChargingTimeToFull) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
battery_bat0_properties.time_to_full = 100;
battery_bat0_properties.percentage = 1;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_TRUE(status.charging);
EXPECT_EQ(100, status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(.01, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, FullyCharged) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state = UPowerDeviceState::UPOWER_DEVICE_STATE_FULL;
battery_bat0_properties.time_to_full = 100;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 100;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_TRUE(status.charging);
EXPECT_EQ(0, status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(1, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, Discharging) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 90;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(.9, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, DischargingTimeToEmptyUnknown) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 0;
battery_bat0_properties.percentage = 90;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(.9, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, DeviceStateUnknown) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_UNKNOWN;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 0;
battery_bat0_properties.percentage = 50;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_TRUE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(.5, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, DeviceStateEmpty) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state = UPowerDeviceState::UPOWER_DEVICE_STATE_EMPTY;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 0;
battery_bat0_properties.percentage = 0;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(0, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, LevelRoundedToThreeSignificantDigits) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.percentage = 14.56;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(0.15, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, UsingFirstBatteryDevice) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 70;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
MockBatteryProperties battery_bat1_properties;
battery_bat1_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
battery_bat1_properties.time_to_full = 100;
battery_bat1_properties.time_to_empty = 0;
battery_bat1_properties.percentage = 80;
AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties);
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(0.7, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, SkipNonBatteryDevice) {
MockBatteryProperties line_power_AC_properties;
line_power_AC_properties.type =
UPowerDeviceType::UPOWER_DEVICE_TYPE_LINE_POWER;
AddDeviceProxy(kUPowerDeviceACLinePath, &line_power_AC_properties);
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 70;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(0.7, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyState) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
battery_bat0_properties.time_to_full = 100;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 80;
MockBatteryObject& battery_bat0 =
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_TRUE(status.charging);
EXPECT_EQ(100, status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(.8, status.level);
int last_count = count_battery_updates();
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyState);
status = last_battery_status();
EXPECT_LT(last_count, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(.8, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyPercentage) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 100;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 80;
MockBatteryObject& battery_bat0 =
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(.8, status.level);
int last_count = count_battery_updates();
battery_bat0_properties.percentage = 70;
DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyPercentage);
status = last_battery_status();
EXPECT_LT(last_count, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(.7, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyTimeToEmpty) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 100;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 80;
MockBatteryObject& battery_bat0 =
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(.8, status.level);
int last_count = count_battery_updates();
battery_bat0_properties.time_to_empty = 150;
DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyTimeToEmpty);
status = last_battery_status();
EXPECT_LT(last_count, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(150, status.discharging_time);
EXPECT_EQ(.8, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyTimeToFull) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
battery_bat0_properties.time_to_full = 100;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 80;
MockBatteryObject& battery_bat0 =
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_TRUE(status.charging);
EXPECT_EQ(100, status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(.8, status.level);
int last_count = count_battery_updates();
battery_bat0_properties.time_to_full = 50;
DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyTimeToFull);
status = last_battery_status();
EXPECT_LT(last_count, count_battery_updates());
EXPECT_TRUE(status.charging);
EXPECT_EQ(50, status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(.8, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, OldDaemonDeviceSignalChanged) {
mock_upower_.daemon_version = "0.9.23";
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 100;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 80;
MockBatteryObject& battery_bat0 =
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalChanged()
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(.8, status.level);
int last_count = count_battery_updates();
battery_bat0_properties.percentage = 70;
DeviceSignalChanged(&battery_bat0);
status = last_battery_status();
EXPECT_LT(last_count, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(.7, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, DisplayDeviceNoBattery) {
MockBatteryProperties display_device_properties;
display_device_properties.type = UPowerDeviceType::UPOWER_DEVICE_TYPE_UNKNOWN;
SetUpDisplayDeviceProxy(&display_device_properties);
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 90;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(0.9, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, DisplayDeviceBattery) {
MockBatteryProperties display_device_properties;
display_device_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
display_device_properties.time_to_full = 0;
display_device_properties.time_to_empty = 200;
display_device_properties.percentage = 90;
SetUpDisplayDeviceProxy(&display_device_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(.9, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, DisplayDeviceBatterySkipsEnumerate) {
MockBatteryProperties display_device_properties;
display_device_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
display_device_properties.time_to_full = 0;
display_device_properties.time_to_empty = 200;
display_device_properties.percentage = 90;
SetUpDisplayDeviceProxy(&display_device_properties)
.ExpectConnectToSignalPropertyChanged();
AddDevicePath(kUPowerDeviceACLinePath);
AddDevicePath(kUPowerDeviceBattery0Path);
AddDevicePath(kUPowerDeviceBattery1Path);
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(.9, status.level);
}
// Adding a display-device will make the BatteryStatusManagerLinux switch to
// the display-device.
TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedDisplayDevice) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 70;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(0.7, status.level);
int last_count = count_battery_updates();
MockBatteryProperties display_device_properties;
display_device_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
display_device_properties.time_to_full = 100;
display_device_properties.time_to_empty = 150;
display_device_properties.percentage = 80;
SetUpDisplayDeviceProxy(&display_device_properties)
.ExpectConnectToSignalPropertyChanged();
UPowerSignalDeviceAdded(mock_upower_.display_device);
status = last_battery_status();
EXPECT_LT(last_count, count_battery_updates());
EXPECT_TRUE(status.charging);
EXPECT_EQ(100, status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(0.8, status.level);
}
// Prepending a battery should switch to that battery.
TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedBatteryAtFront) {
MockBatteryProperties battery_bat1_properties;
battery_bat1_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat1_properties.time_to_full = 0;
battery_bat1_properties.time_to_empty = 200;
battery_bat1_properties.percentage = 70;
AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(0.7, status.level);
int last_count = count_battery_updates();
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 150;
battery_bat0_properties.percentage = 50;
PushFrontDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
UPowerSignalDeviceAdded(kUPowerDeviceBattery0Path);
status = last_battery_status();
EXPECT_LT(last_count, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(150, status.discharging_time);
EXPECT_EQ(0.5, status.level);
}
// Appending a battery should keep the current battery.
TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedBatteryAtBack) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 150;
battery_bat0_properties.percentage = 50;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(150, status.discharging_time);
EXPECT_EQ(0.5, status.level);
int last_count = count_battery_updates();
MockBatteryProperties battery_bat1_properties;
battery_bat1_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat1_properties.time_to_full = 0;
battery_bat1_properties.time_to_empty = 200;
battery_bat1_properties.percentage = 70;
AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties);
UPowerSignalDeviceAdded(kUPowerDeviceBattery1Path);
status = last_battery_status();
EXPECT_LT(last_count, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(150, status.discharging_time);
EXPECT_EQ(0.5, status.level);
}
// Adding a device that is no battery should not change anything.
TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedNoBattery) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 70;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(0.7, status.level);
int last_count = count_battery_updates();
MockBatteryProperties line_power_AC_properties;
line_power_AC_properties.type =
UPowerDeviceType::UPOWER_DEVICE_TYPE_LINE_POWER;
PushFrontDeviceProxy(kUPowerDeviceACLinePath, &line_power_AC_properties);
UPowerSignalDeviceAdded(kUPowerDeviceACLinePath);
status = last_battery_status();
EXPECT_LT(last_count, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(0.7, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceRemovedBattery) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 70;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
MockBatteryProperties battery_bat1_properties;
battery_bat1_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
battery_bat1_properties.time_to_full = 100;
battery_bat1_properties.time_to_empty = 0;
battery_bat1_properties.percentage = 80;
MockBatteryObject& battery_bat1 =
AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties);
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(0.7, status.level);
int last_count = count_battery_updates();
ExpectGetObjectProxy(kUPowerDeviceBattery1Path, &battery_bat1);
battery_bat1.ExpectConnectToSignalPropertyChanged();
EXPECT_EQ(kUPowerDeviceBattery0Path, mock_upower_.devices.front());
mock_upower_.devices.pop_front();
UPowerSignalDeviceRemoved(kUPowerDeviceBattery0Path);
status = last_battery_status();
EXPECT_LT(last_count, count_battery_updates());
EXPECT_TRUE(status.charging);
EXPECT_EQ(100, status.charging_time);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
EXPECT_EQ(0.8, status.level);
}
TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceRemovedOther) {
MockBatteryProperties battery_bat0_properties;
battery_bat0_properties.state =
UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
battery_bat0_properties.time_to_full = 0;
battery_bat0_properties.time_to_empty = 200;
battery_bat0_properties.percentage = 70;
AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
.ExpectConnectToSignalPropertyChanged();
MockBatteryProperties line_power_AC_properties;
line_power_AC_properties.type =
UPowerDeviceType::UPOWER_DEVICE_TYPE_LINE_POWER;
AddDeviceProxy(kUPowerDeviceACLinePath, &line_power_AC_properties);
StartBatteryStatusManagerLinux();
BatteryStatus status = last_battery_status();
EXPECT_LE(1, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(0.7, status.level);
int last_count = count_battery_updates();
mock_upower_.devices.pop_back();
UPowerSignalDeviceRemoved(kUPowerDeviceACLinePath);
status = last_battery_status();
EXPECT_EQ(last_count, count_battery_updates());
EXPECT_FALSE(status.charging);
EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
EXPECT_EQ(200, status.discharging_time);
EXPECT_EQ(0.7, status.level);
}
} // namespace device