services/device/battery/battery_status_manager_linux_unittest.cc

// 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 "services/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 "services/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);
  std::unique_ptr<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;
  }
  std::move(*on_connected_callback)
      .Run(interface_name, signal_name, on_connected_success);
}

std::unique_ptr<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;
    } 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;
    }
  } 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;
      }
    } 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;
    }
  }

  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);
  std::unique_ptr<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;
  }
  std::move(*on_connected_callback)
      .Run(interface_name, signal_name, on_connected_success);
}

std::unique_ptr<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;
      }
    } 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;
    }
  }
  LOG(ERROR) << "Unexpected method call: " << method_call->ToString();
  return nullptr;
}

MockBatteryObject& MockBatteryObject::ExpectConnectToSignalChanged() {
  EXPECT_CALL(*proxy.get(), DoConnectToSignal(kUPowerDeviceInterfaceName,
                                              kUPowerDeviceSignalChanged, _, _))
      .WillOnce(Invoke(this, &MockBatteryObject::ConnectToSignal));
  return *this;
}

MockBatteryObject& MockBatteryObject::ExpectConnectToSignalPropertyChanged() {
  EXPECT_CALL(*proxy.get(), DoConnectToSignal(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 mojom::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 mojom::BatteryStatus& status);
  void SyncWithNotifierThread();

  std::unique_ptr<BatteryStatusManagerLinux> manager_;
  int count_battery_updates_ = 0;
  mojom::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(), CallMethodAndBlock(_, _))
      .WillRepeatedly(
          Invoke(&mock_upower_, &MockUPowerObject::CreateCallMethodResponse));
  EXPECT_CALL(
      *mock_upower_.proxy.get(),
      DoConnectToSignal(kUPowerInterfaceName, kUPowerSignalDeviceAdded, _, _))
      .WillOnce(Invoke(&mock_upower_, &MockUPowerObject::ConnectToSignal));
  EXPECT_CALL(
      *mock_upower_.proxy.get(),
      DoConnectToSignal(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(), CallMethodAndBlock(_, _))
      .WillRepeatedly(Invoke(mock_object.get(),
                             &MockBatteryObject::CreateCallMethodResponse));
  return mock_object;
}

void BatteryStatusManagerLinuxTest::BatteryUpdateCallback(
    const mojom::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) {
  mojom::BatteryStatus default_status;
  StartBatteryStatusManagerLinux();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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();
  mojom::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