1 // Copyright 2020 The Chromium Authors
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/power_monitor/battery_level_provider.h"
6
7 #include "testing/gtest/include/gtest/gtest.h"
8
9 namespace base {
10 namespace {
11
12 class FakeBatteryLevelProvider : public BatteryLevelProvider {
13 public:
14 using BatteryDetails = BatteryLevelProvider::BatteryDetails;
15
16 FakeBatteryLevelProvider() = default;
17
MakeBatteryState(const std::vector<BatteryDetails> & battery_details)18 static BatteryState MakeBatteryState(
19 const std::vector<BatteryDetails>& battery_details) {
20 return BatteryLevelProvider::MakeBatteryState(battery_details);
21 }
22 };
23
24 } // namespace
25
26 using BatteryDetails = FakeBatteryLevelProvider::BatteryDetails;
27
TEST(BatteryLevelProviderTest,NoBattery)28 TEST(BatteryLevelProviderTest, NoBattery) {
29 auto state = FakeBatteryLevelProvider::MakeBatteryState({});
30 EXPECT_EQ(0, state.battery_count);
31 EXPECT_TRUE(state.is_external_power_connected);
32 EXPECT_FALSE(state.current_capacity.has_value());
33 EXPECT_FALSE(state.full_charged_capacity.has_value());
34 EXPECT_NE(base::TimeTicks(), state.capture_time);
35 }
36
TEST(BatteryLevelProviderTest,SingleBatteryWithExternalPower)37 TEST(BatteryLevelProviderTest, SingleBatteryWithExternalPower) {
38 auto state = FakeBatteryLevelProvider::MakeBatteryState(
39 {BatteryDetails({.is_external_power_connected = true,
40 .current_capacity = 42,
41 .full_charged_capacity = 100})});
42 EXPECT_EQ(1, state.battery_count);
43 EXPECT_TRUE(state.is_external_power_connected);
44 EXPECT_EQ(42U, state.current_capacity);
45 EXPECT_EQ(100U, state.full_charged_capacity);
46 EXPECT_NE(base::TimeTicks(), state.capture_time);
47 }
48
TEST(BatteryLevelProviderTest,SingleBatteryDischarging)49 TEST(BatteryLevelProviderTest, SingleBatteryDischarging) {
50 auto state = FakeBatteryLevelProvider::MakeBatteryState(
51 {BatteryDetails({.is_external_power_connected = false,
52 .current_capacity = 42,
53 .full_charged_capacity = 100})});
54 EXPECT_EQ(1, state.battery_count);
55 EXPECT_FALSE(state.is_external_power_connected);
56 EXPECT_EQ(42U, state.current_capacity);
57 EXPECT_EQ(100U, state.full_charged_capacity);
58 EXPECT_NE(base::TimeTicks(), state.capture_time);
59 }
60
TEST(BatteryLevelProviderTest,MultipleBatteriesWithExternalPower)61 TEST(BatteryLevelProviderTest, MultipleBatteriesWithExternalPower) {
62 auto state = FakeBatteryLevelProvider::MakeBatteryState(
63 {BatteryDetails({.is_external_power_connected = false,
64 .current_capacity = 42,
65 .full_charged_capacity = 100}),
66 BatteryDetails({.is_external_power_connected = true,
67 .current_capacity = 10,
68 .full_charged_capacity = 100})});
69 EXPECT_EQ(2, state.battery_count);
70 EXPECT_TRUE(state.is_external_power_connected);
71 EXPECT_EQ(std::nullopt, state.current_capacity);
72 EXPECT_EQ(std::nullopt, state.full_charged_capacity);
73 EXPECT_NE(base::TimeTicks(), state.capture_time);
74 }
75
TEST(BatteryLevelProviderTest,MultipleBatteriesDischarging)76 TEST(BatteryLevelProviderTest, MultipleBatteriesDischarging) {
77 auto state = FakeBatteryLevelProvider::MakeBatteryState(
78 {BatteryDetails({.is_external_power_connected = false,
79 .current_capacity = 42,
80 .full_charged_capacity = 100}),
81 BatteryDetails({.is_external_power_connected = false,
82 .current_capacity = 10,
83 .full_charged_capacity = 100})});
84 EXPECT_EQ(2, state.battery_count);
85 EXPECT_FALSE(state.is_external_power_connected);
86 EXPECT_EQ(std::nullopt, state.current_capacity);
87 EXPECT_EQ(std::nullopt, state.full_charged_capacity);
88 EXPECT_NE(base::TimeTicks(), state.capture_time);
89 }
90
TEST(BatteryLevelProviderTest,SingleBatteryMAh)91 TEST(BatteryLevelProviderTest, SingleBatteryMAh) {
92 auto state = FakeBatteryLevelProvider::MakeBatteryState({BatteryDetails(
93 {.is_external_power_connected = false,
94 .current_capacity = 42,
95 .full_charged_capacity = 100,
96 .voltage_mv = 12,
97 .charge_unit = BatteryLevelProvider::BatteryLevelUnit::kMAh})});
98 EXPECT_EQ(1, state.battery_count);
99 EXPECT_FALSE(state.is_external_power_connected);
100 EXPECT_EQ(42U, state.current_capacity);
101 EXPECT_EQ(100U, state.full_charged_capacity);
102 EXPECT_TRUE(state.voltage_mv.has_value());
103 EXPECT_EQ(12U, *state.voltage_mv);
104 EXPECT_EQ(BatteryLevelProvider::BatteryLevelUnit::kMAh, state.charge_unit);
105 EXPECT_NE(base::TimeTicks(), state.capture_time);
106 }
107
108 } // namespace base
109