ash/system/chromeos/power/power_status_view_unittest.cc

   1 // Copyright 2014 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/power_status_view.h"
   6
   7 #include "ash/system/chromeos/power/power_status.h"
   8 #include "ash/test/ash_test_base.h"
   9 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
  10 #include "grit/ash_strings.h"
  11 #include "ui/base/l10n/l10n_util.h"
  12 #include "ui/base/l10n/time_format.h"
  13 #include "ui/views/controls/label.h"
  14
  15 using power_manager::PowerSupplyProperties;
  16
  17 namespace ash {
  18
  19 class PowerStatusViewTest : public test::AshTestBase {
  20  public:
  21   PowerStatusViewTest() {}
  22   ~PowerStatusViewTest() override {}
  23
  24   // Overridden from testing::Test:
  25   void SetUp() override {
  26     test::AshTestBase::SetUp();
  27     view_.reset(new PowerStatusView(GetViewType(), false));
  28   }
  29
  30   void TearDown() override {
  31     view_.reset();
  32     test::AshTestBase::TearDown();
  33   }
  34
  35  protected:
  36   virtual PowerStatusView::ViewType GetViewType() = 0;
  37   PowerStatusView* view() { return view_.get(); }
  38
  39   void UpdatePowerStatus(const power_manager::PowerSupplyProperties& proto) {
  40     PowerStatus::Get()->SetProtoForTesting(proto);
  41     view_->OnPowerStatusChanged();
  42   }
  43
  44  private:
  45   scoped_ptr<PowerStatusView> view_;
  46
  47   DISALLOW_COPY_AND_ASSIGN(PowerStatusViewTest);
  48 };
  49
  50 class PowerStatusDefaultViewTest : public PowerStatusViewTest {
  51  public:
  52   PowerStatusDefaultViewTest() {}
  53   ~PowerStatusDefaultViewTest() override {}
  54
  55  protected:
  56   PowerStatusView::ViewType GetViewType() override {
  57     return PowerStatusView::VIEW_DEFAULT;
  58   }
  59
  60   bool IsPercentageVisible() {
  61     return view()->percentage_label_->visible();
  62   }
  63
  64   bool IsTimeStatusVisible() {
  65     return view()->time_status_label_->visible();
  66   }
  67
  68   base::string16 RemainingTimeInView() {
  69     return view()->time_status_label_->text();
  70   }
  71
  72  private:
  73   DISALLOW_COPY_AND_ASSIGN(PowerStatusDefaultViewTest);
  74 };
  75
  76 class PowerStatusNotificationViewTest : public PowerStatusViewTest {
  77  public:
  78   PowerStatusNotificationViewTest() {}
  79   ~PowerStatusNotificationViewTest() override {}
  80
  81  protected:
  82   PowerStatusView::ViewType GetViewType() override {
  83     return PowerStatusView::VIEW_NOTIFICATION;
  84   }
  85
  86   base::string16 StatusInView() {
  87     return view()->status_label_->text();
  88   }
  89
  90   base::string16 RemainingTimeInView() {
  91     return view()->time_label_->text();
  92   }
  93
  94  private:
  95   DISALLOW_COPY_AND_ASSIGN(PowerStatusNotificationViewTest);
  96 };
  97
  98 TEST_F(PowerStatusDefaultViewTest, Basic) {
  99   EXPECT_FALSE(IsPercentageVisible());
 100   EXPECT_TRUE(IsTimeStatusVisible());
 101
 102   // Disconnect the power.
 103   PowerSupplyProperties prop;
 104   prop.set_external_power(PowerSupplyProperties::DISCONNECTED);
 105   prop.set_battery_state(PowerSupplyProperties::DISCHARGING);
 106   prop.set_battery_percent(99.0);
 107   prop.set_battery_time_to_empty_sec(120);
 108   prop.set_is_calculating_battery_time(true);
 109   UpdatePowerStatus(prop);
 110
 111   EXPECT_TRUE(IsPercentageVisible());
 112   EXPECT_TRUE(IsTimeStatusVisible());
 113   EXPECT_EQ(l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BATTERY_CALCULATING),
 114             RemainingTimeInView());
 115
 116   prop.set_is_calculating_battery_time(false);
 117   UpdatePowerStatus(prop);
 118   EXPECT_NE(l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BATTERY_CALCULATING),
 119             RemainingTimeInView());
 120   EXPECT_NE(
 121       l10n_util::GetStringUTF16(
 122           IDS_ASH_STATUS_TRAY_BATTERY_CHARGING_UNRELIABLE),
 123       RemainingTimeInView());
 124
 125   prop.set_external_power(PowerSupplyProperties::AC);
 126   prop.set_battery_state(PowerSupplyProperties::CHARGING);
 127   prop.set_battery_time_to_full_sec(120);
 128   UpdatePowerStatus(prop);
 129   EXPECT_TRUE(IsPercentageVisible());
 130   EXPECT_TRUE(IsTimeStatusVisible());
 131   EXPECT_NE(l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BATTERY_CALCULATING),
 132             RemainingTimeInView());
 133   EXPECT_NE(
 134       l10n_util::GetStringUTF16(
 135           IDS_ASH_STATUS_TRAY_BATTERY_CHARGING_UNRELIABLE),
 136       RemainingTimeInView());
 137
 138   prop.set_external_power(PowerSupplyProperties::USB);
 139   UpdatePowerStatus(prop);
 140   EXPECT_TRUE(IsPercentageVisible());
 141   EXPECT_TRUE(IsTimeStatusVisible());
 142   EXPECT_EQ(
 143       l10n_util::GetStringUTF16(
 144           IDS_ASH_STATUS_TRAY_BATTERY_CHARGING_UNRELIABLE),
 145       RemainingTimeInView());
 146
 147   // Tricky -- connected to non-USB but still discharging. Not likely happening
 148   // on production though.
 149   prop.set_external_power(PowerSupplyProperties::AC);
 150   prop.set_battery_state(PowerSupplyProperties::DISCHARGING);
 151   prop.set_battery_time_to_full_sec(120);
 152   UpdatePowerStatus(prop);
 153   EXPECT_TRUE(IsPercentageVisible());
 154   EXPECT_FALSE(IsTimeStatusVisible());
 155 }
 156
 157 TEST_F(PowerStatusNotificationViewTest, Basic) {
 158   EXPECT_EQ(l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BATTERY_FULL),
 159             StatusInView());
 160   EXPECT_TRUE(RemainingTimeInView().empty());
 161
 162   // Disconnect the power.
 163   PowerSupplyProperties prop;
 164   prop.set_external_power(PowerSupplyProperties::DISCONNECTED);
 165   prop.set_battery_state(PowerSupplyProperties::DISCHARGING);
 166   prop.set_battery_percent(99.0);
 167   prop.set_battery_time_to_empty_sec(125);
 168   prop.set_is_calculating_battery_time(true);
 169   UpdatePowerStatus(prop);
 170
 171   EXPECT_NE(l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BATTERY_FULL),
 172             StatusInView());
 173   EXPECT_EQ(l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BATTERY_CALCULATING),
 174             RemainingTimeInView());
 175
 176   prop.set_is_calculating_battery_time(false);
 177   UpdatePowerStatus(prop);
 178   // Low power warning has to be calculated by ui::TimeFormat, but ignore
 179   // seconds.
 180   EXPECT_EQ(ui::TimeFormat::Simple(ui::TimeFormat::FORMAT_REMAINING,
 181                                    ui::TimeFormat::LENGTH_LONG,
 182                                    base::TimeDelta::FromMinutes(2)),
 183             RemainingTimeInView());
 184
 185   prop.set_external_power(PowerSupplyProperties::AC);
 186   prop.set_battery_state(PowerSupplyProperties::CHARGING);
 187   prop.set_battery_time_to_full_sec(120);
 188   UpdatePowerStatus(prop);
 189   EXPECT_NE(l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BATTERY_FULL),
 190             StatusInView());
 191   // Charging time is somehow using another format?
 192   EXPECT_NE(ui::TimeFormat::Simple(ui::TimeFormat::FORMAT_REMAINING,
 193                                    ui::TimeFormat::LENGTH_LONG,
 194                                    base::TimeDelta::FromMinutes(2)),
 195             RemainingTimeInView());
 196
 197   // Unreliable connection.
 198   prop.set_external_power(PowerSupplyProperties::USB);
 199   UpdatePowerStatus(prop);
 200   EXPECT_EQ(
 201       l10n_util::GetStringUTF16(
 202           IDS_ASH_STATUS_TRAY_BATTERY_CHARGING_UNRELIABLE),
 203       RemainingTimeInView());
 204
 205   // Tricky -- connected to non-USB but still discharging. Not likely happening
 206   // on production though.
 207   prop.set_external_power(PowerSupplyProperties::AC);
 208   prop.set_battery_state(PowerSupplyProperties::DISCHARGING);
 209   prop.set_battery_time_to_full_sec(120);
 210   UpdatePowerStatus(prop);
 211   EXPECT_TRUE(RemainingTimeInView().empty());
 212 }
 213
 214 }  // namespace ash