src/ash/system/chromeos/power/tray_power_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/system/chromeos/power/tray_power.h"
   6
   7 #include "ash/ash_switches.h"
   8 #include "ash/test/ash_test_base.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
  11 #include "ui/message_center/fake_message_center.h"
  12
  13 using message_center::Notification;
  14 using power_manager::PowerSupplyProperties;
  15
  16 namespace {
  17
  18 class MockMessageCenter : public message_center::FakeMessageCenter {
  19  public:
  20   MockMessageCenter() : add_count_(0), remove_count_(0) {}
  21   virtual ~MockMessageCenter() {}
  22
  23   int add_count() const { return add_count_; }
  24   int remove_count() const { return remove_count_; }
  25
  26   // message_center::FakeMessageCenter overrides:
  27   virtual void AddNotification(scoped_ptr<Notification> notification) override {
  28     add_count_++;
  29   }
  30   virtual void RemoveNotification(const std::string& id, bool by_user)
  31       override {
  32     remove_count_++;
  33   }
  34
  35  private:
  36   int add_count_;
  37   int remove_count_;
  38
  39   DISALLOW_COPY_AND_ASSIGN(MockMessageCenter);
  40 };
  41
  42 }  // namespace
  43
  44 namespace ash {
  45
  46 class TrayPowerTest : public test::AshTestBase {
  47  public:
  48   TrayPowerTest() {}
  49   virtual ~TrayPowerTest() {}
  50
  51   MockMessageCenter* message_center() { return message_center_.get(); }
  52   TrayPower* tray_power() { return tray_power_.get(); }
  53
  54   // test::AshTestBase::SetUp() overrides:
  55   virtual void SetUp() override {
  56     test::AshTestBase::SetUp();
  57     message_center_.reset(new MockMessageCenter());
  58     tray_power_.reset(new TrayPower(NULL, message_center_.get()));
  59   }
  60
  61   virtual void TearDown() override {
  62     tray_power_.reset();
  63     message_center_.reset();
  64     test::AshTestBase::TearDown();
  65   }
  66
  67   TrayPower::NotificationState notification_state() const {
  68     return tray_power_->notification_state_;
  69   }
  70
  71   bool MaybeShowUsbChargerNotification(const PowerSupplyProperties& proto) {
  72     PowerStatus::Get()->SetProtoForTesting(proto);
  73     return tray_power_->MaybeShowUsbChargerNotification();
  74   }
  75
  76   bool UpdateNotificationState(const PowerSupplyProperties& proto) {
  77     PowerStatus::Get()->SetProtoForTesting(proto);
  78     return tray_power_->UpdateNotificationState();
  79   }
  80
  81   void SetUsbChargerConnected(bool connected) {
  82     tray_power_->usb_charger_was_connected_ = connected;
  83    }
  84
  85   // Returns a discharging PowerSupplyProperties more appropriate for testing.
  86   static PowerSupplyProperties DefaultPowerSupplyProperties() {
  87     PowerSupplyProperties proto;
  88     proto.set_external_power(
  89         power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED);
  90     proto.set_battery_state(
  91         power_manager::PowerSupplyProperties_BatteryState_DISCHARGING);
  92     proto.set_battery_percent(50.0);
  93     proto.set_battery_time_to_empty_sec(3 * 60 * 60);
  94     proto.set_battery_time_to_full_sec(2 * 60 * 60);
  95     proto.set_is_calculating_battery_time(false);
  96     return proto;
  97   }
  98
  99  private:
 100   scoped_ptr<MockMessageCenter> message_center_;
 101   scoped_ptr<TrayPower> tray_power_;
 102
 103   DISALLOW_COPY_AND_ASSIGN(TrayPowerTest);
 104 };
 105
 106 TEST_F(TrayPowerTest, MaybeShowUsbChargerNotification) {
 107   PowerSupplyProperties discharging = DefaultPowerSupplyProperties();
 108   EXPECT_FALSE(MaybeShowUsbChargerNotification(discharging));
 109   EXPECT_EQ(0, message_center()->add_count());
 110   EXPECT_EQ(0, message_center()->remove_count());
 111
 112   // Notification shows when connecting a USB charger.
 113   PowerSupplyProperties usb_connected = DefaultPowerSupplyProperties();
 114   usb_connected.set_external_power(
 115       power_manager::PowerSupplyProperties_ExternalPower_USB);
 116   EXPECT_TRUE(MaybeShowUsbChargerNotification(usb_connected));
 117   EXPECT_EQ(1, message_center()->add_count());
 118   EXPECT_EQ(0, message_center()->remove_count());
 119
 120   // Change in charge does not trigger the notification again.
 121   PowerSupplyProperties more_charge = DefaultPowerSupplyProperties();
 122   more_charge.set_external_power(
 123       power_manager::PowerSupplyProperties_ExternalPower_USB);
 124   more_charge.set_battery_time_to_full_sec(60 * 60);
 125   more_charge.set_battery_percent(75.0);
 126   SetUsbChargerConnected(true);
 127   EXPECT_FALSE(MaybeShowUsbChargerNotification(more_charge));
 128   EXPECT_EQ(1, message_center()->add_count());
 129   EXPECT_EQ(0, message_center()->remove_count());
 130
 131   // Disconnecting a USB charger with the notification showing should close
 132   // the notification.
 133   EXPECT_TRUE(MaybeShowUsbChargerNotification(discharging));
 134   EXPECT_EQ(1, message_center()->add_count());
 135   EXPECT_EQ(1, message_center()->remove_count());
 136 }
 137
 138 TEST_F(TrayPowerTest, UpdateNotificationState) {
 139   // No notifications when no battery present.
 140   PowerSupplyProperties no_battery = DefaultPowerSupplyProperties();
 141   no_battery.set_external_power(
 142       power_manager::PowerSupplyProperties_ExternalPower_AC);
 143   no_battery.set_battery_state(
 144       power_manager::PowerSupplyProperties_BatteryState_NOT_PRESENT);
 145   EXPECT_FALSE(UpdateNotificationState(no_battery));
 146   EXPECT_EQ(TrayPower::NOTIFICATION_NONE, notification_state());
 147
 148   // No notification when calculating remaining battery time.
 149   PowerSupplyProperties calculating = DefaultPowerSupplyProperties();
 150   calculating.set_is_calculating_battery_time(true);
 151   EXPECT_FALSE(UpdateNotificationState(calculating));
 152   EXPECT_EQ(TrayPower::NOTIFICATION_NONE, notification_state());
 153
 154   // No notification when charging.
 155   PowerSupplyProperties charging = DefaultPowerSupplyProperties();
 156   charging.set_external_power(
 157       power_manager::PowerSupplyProperties_ExternalPower_AC);
 158   charging.set_battery_state(
 159       power_manager::PowerSupplyProperties_BatteryState_CHARGING);
 160   EXPECT_FALSE(UpdateNotificationState(charging));
 161   EXPECT_EQ(TrayPower::NOTIFICATION_NONE, notification_state());
 162
 163   // When the rounded minutes-to-empty are above the threshold, no notification
 164   // should be shown.
 165   PowerSupplyProperties low = DefaultPowerSupplyProperties();
 166   low.set_battery_time_to_empty_sec(TrayPower::kLowPowerMinutes * 60 + 30);
 167   EXPECT_FALSE(UpdateNotificationState(low));
 168   EXPECT_EQ(TrayPower::NOTIFICATION_NONE, notification_state());
 169
 170   // When the rounded value matches the threshold, the notification should
 171   // appear.
 172   low.set_battery_time_to_empty_sec(TrayPower::kLowPowerMinutes * 60 + 29);
 173   EXPECT_TRUE(UpdateNotificationState(low));
 174   EXPECT_EQ(TrayPower::NOTIFICATION_LOW_POWER, notification_state());
 175
 176   // It should persist at lower values.
 177   low.set_battery_time_to_empty_sec(TrayPower::kLowPowerMinutes * 60 - 20);
 178   EXPECT_FALSE(UpdateNotificationState(low));
 179   EXPECT_EQ(TrayPower::NOTIFICATION_LOW_POWER, notification_state());
 180
 181   // The critical low battery notification should be shown when the rounded
 182   // value is at the lower threshold.
 183   PowerSupplyProperties critical = DefaultPowerSupplyProperties();
 184   critical.set_battery_time_to_empty_sec(TrayPower::kCriticalMinutes * 60 + 29);
 185   EXPECT_TRUE(UpdateNotificationState(critical));
 186   EXPECT_EQ(TrayPower::NOTIFICATION_CRITICAL, notification_state());
 187
 188   // The notification should be dismissed when the no-warning threshold is
 189   // reached.
 190   PowerSupplyProperties safe = DefaultPowerSupplyProperties();
 191   safe.set_battery_time_to_empty_sec(TrayPower::kNoWarningMinutes * 60 - 29);
 192   EXPECT_FALSE(UpdateNotificationState(safe));
 193   EXPECT_EQ(TrayPower::NOTIFICATION_NONE, notification_state());
 194
 195   // Test that rounded percentages are used when a USB charger is connected.
 196   PowerSupplyProperties low_usb = DefaultPowerSupplyProperties();
 197   low_usb.set_external_power(
 198       power_manager::PowerSupplyProperties_ExternalPower_USB);
 199   low_usb.set_battery_percent(TrayPower::kLowPowerPercentage + 0.5);
 200   EXPECT_FALSE(UpdateNotificationState(low_usb));
 201   EXPECT_EQ(TrayPower::NOTIFICATION_NONE, notification_state());
 202
 203   low_usb.set_battery_percent(TrayPower::kLowPowerPercentage + 0.49);
 204   EXPECT_TRUE(UpdateNotificationState(low_usb));
 205   EXPECT_EQ(TrayPower::NOTIFICATION_LOW_POWER, notification_state());
 206
 207   PowerSupplyProperties critical_usb = DefaultPowerSupplyProperties();
 208   critical_usb.set_external_power(
 209       power_manager::PowerSupplyProperties_ExternalPower_USB);
 210   critical_usb.set_battery_percent(TrayPower::kCriticalPercentage + 0.2);
 211   EXPECT_TRUE(UpdateNotificationState(critical_usb));
 212   EXPECT_EQ(TrayPower::NOTIFICATION_CRITICAL, notification_state());
 213
 214   PowerSupplyProperties safe_usb = DefaultPowerSupplyProperties();
 215   safe_usb.set_external_power(
 216       power_manager::PowerSupplyProperties_ExternalPower_USB);
 217   safe_usb.set_battery_percent(TrayPower::kNoWarningPercentage - 0.1);
 218   EXPECT_FALSE(UpdateNotificationState(safe_usb));
 219   EXPECT_EQ(TrayPower::NOTIFICATION_NONE, notification_state());
 220
 221   // A notification shouldn't be shown when we're in the full state with an
 222   // original Spring charger connected: http://crbug.com/338376
 223   PowerSupplyProperties spring = DefaultPowerSupplyProperties();
 224   spring.set_external_power(power_manager::
 225       PowerSupplyProperties_ExternalPower_ORIGINAL_SPRING_CHARGER);
 226   spring.set_battery_state(
 227       power_manager::PowerSupplyProperties_BatteryState_FULL);
 228   spring.set_battery_time_to_empty_sec(0);
 229   spring.set_battery_time_to_full_sec(0);
 230   EXPECT_FALSE(UpdateNotificationState(spring));
 231   EXPECT_EQ(TrayPower::NOTIFICATION_NONE, notification_state());
 232 }
 233
 234 }  // namespace ash