Index: device/battery/battery_status_manager_linux_unittest.cc |
diff --git a/device/battery/battery_status_manager_linux_unittest.cc b/device/battery/battery_status_manager_linux_unittest.cc |
index d1b882e03c1130c5f68710c81740d02c4f2cbd2f..68e28acb5ec3639d59a35d63af09518a069c7616 100644 |
--- a/device/battery/battery_status_manager_linux_unittest.cc |
+++ b/device/battery/battery_status_manager_linux_unittest.cc |
@@ -4,17 +4,541 @@ |
#include "device/battery/battery_status_manager_linux.h" |
-#include "base/values.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(); |
+} |
-TEST(BatteryStatusManagerLinuxTest, EmptyDictionary) { |
- base::DictionaryValue dictionary; |
+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; |
- BatteryStatus status = ComputeWebBatteryStatus(dictionary); |
+ 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); |
@@ -22,13 +546,18 @@ TEST(BatteryStatusManagerLinuxTest, EmptyDictionary) { |
EXPECT_EQ(default_status.level, status.level); |
} |
-TEST(BatteryStatusManagerLinuxTest, ChargingHalfFull) { |
- base::DictionaryValue dictionary; |
- dictionary.SetDouble("State", UPOWER_DEVICE_STATE_CHARGING); |
- dictionary.SetDouble("TimeToFull", 0); |
- dictionary.SetDouble("Percentage", 50); |
+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(); |
- BatteryStatus status = ComputeWebBatteryStatus(dictionary); |
+ 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); |
@@ -36,13 +565,18 @@ TEST(BatteryStatusManagerLinuxTest, ChargingHalfFull) { |
EXPECT_EQ(0.5, status.level); |
} |
-TEST(BatteryStatusManagerLinuxTest, ChargingTimeToFull) { |
- base::DictionaryValue dictionary; |
- dictionary.SetDouble("State", UPOWER_DEVICE_STATE_CHARGING); |
- dictionary.SetDouble("TimeToFull", 100.f); |
- dictionary.SetDouble("Percentage", 1); |
+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(); |
- BatteryStatus status = ComputeWebBatteryStatus(dictionary); |
+ StartBatteryStatusManagerLinux(); |
+ BatteryStatus status = last_battery_status(); |
+ EXPECT_LE(1, count_battery_updates()); |
EXPECT_TRUE(status.charging); |
EXPECT_EQ(100, status.charging_time); |
@@ -50,14 +584,18 @@ TEST(BatteryStatusManagerLinuxTest, ChargingTimeToFull) { |
EXPECT_EQ(.01, status.level); |
} |
-TEST(BatteryStatusManagerLinuxTest, FullyCharged) { |
- base::DictionaryValue dictionary; |
- dictionary.SetDouble("State", UPOWER_DEVICE_STATE_FULL); |
- dictionary.SetDouble("TimeToFull", 100); |
- dictionary.SetDouble("TimeToEmpty", 200); |
- dictionary.SetDouble("Percentage", 100); |
+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(); |
- BatteryStatus status = ComputeWebBatteryStatus(dictionary); |
+ StartBatteryStatusManagerLinux(); |
+ BatteryStatus status = last_battery_status(); |
+ EXPECT_LE(1, count_battery_updates()); |
EXPECT_TRUE(status.charging); |
EXPECT_EQ(0, status.charging_time); |
@@ -65,14 +603,19 @@ TEST(BatteryStatusManagerLinuxTest, FullyCharged) { |
EXPECT_EQ(1, status.level); |
} |
-TEST(BatteryStatusManagerLinuxTest, Discharging) { |
- base::DictionaryValue dictionary; |
- dictionary.SetDouble("State", UPOWER_DEVICE_STATE_DISCHARGING); |
- dictionary.SetDouble("TimeToFull", 0); |
- dictionary.SetDouble("TimeToEmpty", 200); |
- dictionary.SetDouble("Percentage", 90); |
+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(); |
- BatteryStatus status = ComputeWebBatteryStatus(dictionary); |
+ 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); |
@@ -80,14 +623,19 @@ TEST(BatteryStatusManagerLinuxTest, Discharging) { |
EXPECT_EQ(.9, status.level); |
} |
-TEST(BatteryStatusManagerLinuxTest, DischargingTimeToEmptyUnknown) { |
- base::DictionaryValue dictionary; |
- dictionary.SetDouble("State", UPOWER_DEVICE_STATE_DISCHARGING); |
- dictionary.SetDouble("TimeToFull", 0); |
- dictionary.SetDouble("TimeToEmpty", 0); |
- dictionary.SetDouble("Percentage", 90); |
+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(); |
- BatteryStatus status = ComputeWebBatteryStatus(dictionary); |
+ 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); |
@@ -95,14 +643,19 @@ TEST(BatteryStatusManagerLinuxTest, DischargingTimeToEmptyUnknown) { |
EXPECT_EQ(.9, status.level); |
} |
-TEST(BatteryStatusManagerLinuxTest, DeviceStateUnknown) { |
- base::DictionaryValue dictionary; |
- dictionary.SetDouble("State", UPOWER_DEVICE_STATE_UNKNOWN); |
- dictionary.SetDouble("TimeToFull", 0); |
- dictionary.SetDouble("TimeToEmpty", 0); |
- dictionary.SetDouble("Percentage", 50); |
+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(); |
- BatteryStatus status = ComputeWebBatteryStatus(dictionary); |
+ 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); |
@@ -110,14 +663,18 @@ TEST(BatteryStatusManagerLinuxTest, DeviceStateUnknown) { |
EXPECT_EQ(.5, status.level); |
} |
-TEST(BatteryStatusManagerLinuxTest, DeviceStateEmpty) { |
- base::DictionaryValue dictionary; |
- dictionary.SetDouble("State", UPOWER_DEVICE_STATE_EMPTY); |
- dictionary.SetDouble("TimeToFull", 0); |
- dictionary.SetDouble("TimeToEmpty", 0); |
- dictionary.SetDouble("Percentage", 0); |
+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(); |
- BatteryStatus status = ComputeWebBatteryStatus(dictionary); |
+ 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); |
@@ -125,12 +682,17 @@ TEST(BatteryStatusManagerLinuxTest, DeviceStateEmpty) { |
EXPECT_EQ(0, status.level); |
} |
-TEST(BatteryStatusManagerLinuxTest, LevelRoundedToThreeSignificantDigits) { |
- base::DictionaryValue dictionary; |
- dictionary.SetDouble("State", UPOWER_DEVICE_STATE_DISCHARGING); |
- dictionary.SetDouble("Percentage", 14.56); |
+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(); |
- BatteryStatus status = ComputeWebBatteryStatus(dictionary); |
+ 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); |
@@ -138,6 +700,522 @@ TEST(BatteryStatusManagerLinuxTest, LevelRoundedToThreeSignificantDigits) { |
EXPECT_EQ(0.15, status.level); |
} |
-} // namespace |
+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 |