device/battery/battery_status_service_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 "base/bind.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "base/run_loop.h"
   8 #include "device/battery/battery_status_manager.h"
   9 #include "device/battery/battery_status_service.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace device {
  13
  14 namespace {
  15
  16 class FakeBatteryManager : public BatteryStatusManager {
  17  public:
  18   explicit FakeBatteryManager(
  19       const BatteryStatusService::BatteryUpdateCallback& callback)
  20       : callback_(callback), start_invoked_count_(0), stop_invoked_count_(0) {}
  21   ~FakeBatteryManager() override {}
  22
  23   // Methods from Battery Status Manager
  24   bool StartListeningBatteryChange() override {
  25     start_invoked_count_++;
  26     return true;
  27   }
  28
  29   void StopListeningBatteryChange() override { stop_invoked_count_++; }
  30
  31   void InvokeUpdateCallback(const BatteryStatus& status) {
  32     callback_.Run(status);
  33   }
  34
  35   int start_invoked_count() const { return start_invoked_count_; }
  36   int stop_invoked_count() const { return stop_invoked_count_; }
  37
  38  private:
  39   BatteryStatusService::BatteryUpdateCallback callback_;
  40   int start_invoked_count_;
  41   int stop_invoked_count_;
  42
  43   DISALLOW_COPY_AND_ASSIGN(FakeBatteryManager);
  44 };
  45
  46 class BatteryStatusServiceTest : public testing::Test {
  47  public:
  48     BatteryStatusServiceTest()
  49         : battery_service_(NULL),
  50           battery_manager_(NULL),
  51           callback1_invoked_count_(0),
  52           callback2_invoked_count_(0) {
  53     }
  54     ~BatteryStatusServiceTest() override {}
  55
  56  protected:
  57   typedef BatteryStatusService::BatteryUpdateSubscription BatterySubscription;
  58
  59   void SetUp() override {
  60     callback1_ = base::Bind(&BatteryStatusServiceTest::Callback1,
  61                             base::Unretained(this));
  62     callback2_ = base::Bind(&BatteryStatusServiceTest::Callback2,
  63                             base::Unretained(this));
  64     battery_service_ = BatteryStatusService::GetInstance();
  65
  66     // We keep a raw pointer to the FakeBatteryManager, which we expect to
  67     // remain valid for the lifetime of the BatteryStatusService.
  68     scoped_ptr<FakeBatteryManager> battery_manager(new FakeBatteryManager(
  69         battery_service_->GetUpdateCallbackForTesting()));
  70     battery_manager_ = battery_manager.get();
  71
  72     battery_service_->SetBatteryManagerForTesting(battery_manager.Pass());
  73   }
  74
  75   void TearDown() override {
  76     base::RunLoop().RunUntilIdle();
  77     battery_service_->SetBatteryManagerForTesting(
  78         scoped_ptr<BatteryStatusManager>());
  79   }
  80
  81   FakeBatteryManager* battery_manager() {
  82     return battery_manager_;
  83   }
  84
  85   scoped_ptr<BatterySubscription> AddCallback(
  86       const BatteryStatusService::BatteryUpdateCallback& callback) {
  87     return battery_service_->AddCallback(callback);
  88   }
  89
  90   int callback1_invoked_count() const {
  91     return callback1_invoked_count_;
  92   }
  93
  94   int callback2_invoked_count() const {
  95     return callback2_invoked_count_;
  96   }
  97
  98   const BatteryStatus& battery_status() const {
  99     return battery_status_;
 100   }
 101
 102   const BatteryStatusService::BatteryUpdateCallback& callback1() const {
 103     return callback1_;
 104   }
 105
 106   const BatteryStatusService::BatteryUpdateCallback& callback2() const {
 107     return callback2_;
 108   }
 109
 110  private:
 111   void Callback1(const BatteryStatus& status) {
 112     callback1_invoked_count_++;
 113     battery_status_ = status;
 114   }
 115
 116   void Callback2(const BatteryStatus& status) {
 117     callback2_invoked_count_++;
 118     battery_status_ = status;
 119   }
 120
 121   base::MessageLoop message_loop_;
 122   BatteryStatusService* battery_service_;
 123   FakeBatteryManager* battery_manager_;
 124   BatteryStatusService::BatteryUpdateCallback callback1_;
 125   BatteryStatusService::BatteryUpdateCallback callback2_;
 126   int callback1_invoked_count_;
 127   int callback2_invoked_count_;
 128   BatteryStatus battery_status_;
 129
 130   DISALLOW_COPY_AND_ASSIGN(BatteryStatusServiceTest);
 131 };
 132
 133 TEST_F(BatteryStatusServiceTest, AddFirstCallback) {
 134   scoped_ptr<BatterySubscription> subscription1 = AddCallback(callback1());
 135   EXPECT_EQ(1, battery_manager()->start_invoked_count());
 136   EXPECT_EQ(0, battery_manager()->stop_invoked_count());
 137   subscription1.reset();
 138   EXPECT_EQ(1, battery_manager()->start_invoked_count());
 139   EXPECT_EQ(1, battery_manager()->stop_invoked_count());
 140 }
 141
 142 // Fails on Windows. http://crbug.com/429942.
 143 #if defined(OS_WIN)
 144 #define MAYBE_AddCallbackAfterUpdate DISABLED_AddCallbackAfterUpdate
 145 #else
 146 #define MAYBE_AddCallbackAfterUpdate AddCallbackAfterUpdate
 147 #endif
 148 TEST_F(BatteryStatusServiceTest, MAYBE_AddCallbackAfterUpdate) {
 149   scoped_ptr<BatterySubscription> subscription1 = AddCallback(callback1());
 150   BatteryStatus status;
 151   battery_manager()->InvokeUpdateCallback(status);
 152   base::RunLoop().RunUntilIdle();
 153   EXPECT_EQ(1, callback1_invoked_count());
 154   EXPECT_EQ(0, callback2_invoked_count());
 155
 156   scoped_ptr<BatterySubscription> subscription2 = AddCallback(callback2());
 157   EXPECT_EQ(1, callback1_invoked_count());
 158   EXPECT_EQ(1, callback2_invoked_count());
 159 }
 160
 161 // Fails on Windows. http://crbug.com/429942.
 162 #if defined(OS_WIN)
 163 #define MAYBE_TwoCallbacksUpdate DISABLED_TwoCallbacksUpdate
 164 #else
 165 #define MAYBE_TwoCallbacksUpdate TwoCallbacksUpdate
 166 #endif
 167 TEST_F(BatteryStatusServiceTest, MAYBE_TwoCallbacksUpdate) {
 168   scoped_ptr<BatterySubscription> subscription1 = AddCallback(callback1());
 169   scoped_ptr<BatterySubscription> subscription2 = AddCallback(callback2());
 170
 171   BatteryStatus status;
 172   status.charging = true;
 173   status.charging_time = 100;
 174   status.discharging_time = 200;
 175   status.level = 0.5;
 176   battery_manager()->InvokeUpdateCallback(status);
 177   base::RunLoop().RunUntilIdle();
 178
 179   EXPECT_EQ(1, callback1_invoked_count());
 180   EXPECT_EQ(1, callback2_invoked_count());
 181   EXPECT_EQ(status.charging, battery_status().charging);
 182   EXPECT_EQ(status.charging_time, battery_status().charging_time);
 183   EXPECT_EQ(status.discharging_time, battery_status().discharging_time);
 184   EXPECT_EQ(status.level, battery_status().level);
 185 }
 186
 187 // Fails on Windows. http://crbug.com/429942.
 188 #if defined(OS_WIN)
 189 #define MAYBE_RemoveOneCallback DISABLED_RemoveOneCallback
 190 #else
 191 #define MAYBE_RemoveOneCallback RemoveOneCallback
 192 #endif
 193 TEST_F(BatteryStatusServiceTest, MAYBE_RemoveOneCallback) {
 194   scoped_ptr<BatterySubscription> subscription1 = AddCallback(callback1());
 195   scoped_ptr<BatterySubscription> subscription2 = AddCallback(callback2());
 196
 197   BatteryStatus status;
 198   battery_manager()->InvokeUpdateCallback(status);
 199   base::RunLoop().RunUntilIdle();
 200   EXPECT_EQ(1, callback1_invoked_count());
 201   EXPECT_EQ(1, callback2_invoked_count());
 202
 203   subscription1.reset();
 204   battery_manager()->InvokeUpdateCallback(status);
 205   base::RunLoop().RunUntilIdle();
 206   EXPECT_EQ(1, callback1_invoked_count());
 207   EXPECT_EQ(2, callback2_invoked_count());
 208 }
 209
 210 }  // namespace
 211
 212 }  // namespace device