1 /*
2 * Copyright (C) 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "BatteryDefender.h"
18
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21
22 #include <utils/Timers.h>
23
24 #include <android-base/file.h>
25 #include <android-base/properties.h>
26
27 #define MIN_TIME_BETWEEN_FILE_UPDATES (30 + 1)
28
29 class HealthInterface {
30 public:
~HealthInterface()31 virtual ~HealthInterface() {}
32 virtual bool ReadFileToString(const std::string &path, std::string *content,
33 bool follow_symlinks);
34 virtual int GetIntProperty(const std::string &key, int default_value, int min, int max);
35 virtual bool GetBoolProperty(const std::string &key, bool default_value);
36 virtual bool SetProperty(const std::string &key, const std::string &value);
37 virtual bool WriteStringToFile(const std::string &content, const std::string &path,
38 bool follow_symlinks);
39 };
40
41 class HealthInterfaceMock : public HealthInterface {
42 public:
~HealthInterfaceMock()43 virtual ~HealthInterfaceMock() {}
44
45 MOCK_METHOD3(ReadFileToString,
46 bool(const std::string &path, std::string *content, bool follow_symlinks));
47 MOCK_METHOD4(GetIntProperty, int(const std::string &key, int default_value, int min, int max));
48 MOCK_METHOD2(GetBoolProperty, bool(const std::string &key, bool default_value));
49 MOCK_METHOD2(SetProperty, bool(const std::string &key, const std::string &value));
50 MOCK_METHOD3(WriteStringToFile,
51 bool(const std::string &content, const std::string &path, bool follow_symlinks));
52 };
53
54 HealthInterfaceMock *mock;
55
56 namespace android {
57 namespace base {
58
ReadFileToString(const std::string & path,std::string * content,bool follow_symlinks)59 bool ReadFileToString(const std::string &path, std::string *content, bool follow_symlinks) {
60 return mock->ReadFileToString(path, content, follow_symlinks);
61 }
62
WriteStringToFile(const std::string & content,const std::string & path,bool follow_symlinks)63 bool WriteStringToFile(const std::string &content, const std::string &path, bool follow_symlinks) {
64 return mock->WriteStringToFile(content, path, follow_symlinks);
65 }
66
67 template <typename T>
GetIntProperty(const std::string & key,T default_value,T min,T max)68 T GetIntProperty(const std::string &key, T default_value, T min, T max) {
69 return (T)(mock->GetIntProperty(key, default_value, min, max));
70 }
71
GetBoolProperty(const std::string & key,bool default_value)72 bool GetBoolProperty(const std::string &key, bool default_value) {
73 return mock->GetBoolProperty(key, default_value);
74 }
75
76 template int8_t GetIntProperty(const std::string &, int8_t, int8_t, int8_t);
77 template int16_t GetIntProperty(const std::string &, int16_t, int16_t, int16_t);
78 template int32_t GetIntProperty(const std::string &, int32_t, int32_t, int32_t);
79 template int64_t GetIntProperty(const std::string &, int64_t, int64_t, int64_t);
80
SetProperty(const std::string & key,const std::string & value)81 bool SetProperty(const std::string &key, const std::string &value) {
82 return mock->SetProperty(key, value);
83 }
84
85 } // namespace base
86 } // namespace android
87
88 nsecs_t testvar_systemTimeSecs = 0;
systemTime(int clock)89 nsecs_t systemTime(int clock) {
90 UNUSED(clock);
91 return seconds_to_nanoseconds(testvar_systemTimeSecs);
92 }
93
94 namespace hardware {
95 namespace google {
96 namespace pixel {
97 namespace health {
98
99 using ::testing::_;
100 using ::testing::AnyNumber;
101 using ::testing::AtLeast;
102 using ::testing::DoAll;
103 using ::testing::InSequence;
104 using ::testing::Return;
105 using ::testing::SetArgPointee;
106
107 struct android::BatteryProperties props;
108
109 class BatteryDefenderTest : public ::testing::Test {
110 public:
BatteryDefenderTest()111 BatteryDefenderTest() {}
112
SetUp()113 void SetUp() {
114 mock = &mockFixture;
115
116 props = {};
117
118 EXPECT_CALL(*mock, SetProperty(_, _)).Times(AnyNumber());
119 EXPECT_CALL(*mock, ReadFileToString(_, _, _)).Times(AnyNumber());
120 EXPECT_CALL(*mock, GetIntProperty(_, _, _, _)).Times(AnyNumber());
121 EXPECT_CALL(*mock, GetBoolProperty(_, _)).Times(AnyNumber());
122 EXPECT_CALL(*mock, WriteStringToFile(_, _, _)).Times(AnyNumber());
123
124 ON_CALL(*mock, ReadFileToString(_, _, _))
125 .WillByDefault(DoAll(SetArgPointee<1>(std::string("0")), Return(true)));
126
127 ON_CALL(*mock, WriteStringToFile(_, _, _)).WillByDefault(Return(true));
128 }
129
TearDown()130 void TearDown() {}
131
132 private:
133 HealthInterfaceMock mockFixture;
134 };
135
136 const char *kPathWiredChargerPresent = "/sys/class/power_supply/usb/present";
137 const char *kPathWirelessChargerPresent = "/sys/class/power_supply/wireless/present";
138 const char *kPathPersistChargerPresentTime = "/mnt/vendor/persist/battery/defender_charger_time";
139 const char *kPathPersistDefenderActiveTime = "/mnt/vendor/persist/battery/defender_active_time";
140 const char *kPathStartLevel = "/sys/devices/platform/soc/soc:google,charger/charge_start_level";
141 const char *kPathStopLevel = "/sys/devices/platform/soc/soc:google,charger/charge_stop_level";
142
143 const char *kPropChargeLevelVendorStart = "persist.vendor.charge.start.level";
144 const char *kPropChargeLevelVendorStop = "persist.vendor.charge.stop.level";
145 const char *kPropBatteryDefenderState = "vendor.battery.defender.state";
146 const char *kPropBatteryDefenderDisable = "vendor.battery.defender.disable";
147 const char *kPropBatteryDefenderThreshold = "vendor.battery.defender.threshold";
148
149 const char *kPropBatteryDefenderCtrlEnable = "vendor.battery.defender.ctrl.enable";
150 const char *kPropBatteryDefenderCtrlActivateTime = "vendor.battery.defender.ctrl.trigger_time";
151 const char *kPropBatteryDefenderCtrlResumeTime = "vendor.battery.defender.ctrl.resume_time";
152 const char *kPropBatteryDefenderCtrlStartSOC = "vendor.battery.defender.ctrl.recharge_soc_start";
153 const char *kPropBatteryDefenderCtrlStopSOC = "vendor.battery.defender.ctrl.recharge_soc_stop";
154 const char *kPropBatteryDefenderCtrlTriggerSOC = "vendor.battery.defender.ctrl.trigger_soc";
155
enableDefender(void)156 static void enableDefender(void) {
157 ON_CALL(*mock, GetIntProperty(kPropChargeLevelVendorStart, _, _, _)).WillByDefault(Return(0));
158 ON_CALL(*mock, GetIntProperty(kPropChargeLevelVendorStop, _, _, _)).WillByDefault(Return(100));
159 ON_CALL(*mock, GetBoolProperty(kPropBatteryDefenderDisable, _)).WillByDefault(Return(false));
160
161 ON_CALL(*mock, GetBoolProperty(kPropBatteryDefenderCtrlEnable, _)).WillByDefault(Return(true));
162 }
163
usbPresent(void)164 static void usbPresent(void) {
165 ON_CALL(*mock, ReadFileToString(kPathWiredChargerPresent, _, _))
166 .WillByDefault(DoAll(SetArgPointee<1>(std::string("1")), Return(true)));
167 }
168
wirelessPresent(void)169 static void wirelessPresent(void) {
170 ON_CALL(*mock, ReadFileToString(kPathWirelessChargerPresent, _, _))
171 .WillByDefault(DoAll(SetArgPointee<1>(std::string("1")), Return(true)));
172 }
173
wirelessNotPresent(void)174 static void wirelessNotPresent(void) {
175 ON_CALL(*mock, ReadFileToString(kPathWirelessChargerPresent, _, _))
176 .WillByDefault(DoAll(SetArgPointee<1>(std::string("0")), Return(true)));
177 }
178
powerAvailable(void)179 static void powerAvailable(void) {
180 wirelessPresent();
181 usbPresent();
182 }
183
defaultThresholds(void)184 static void defaultThresholds(void) {
185 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderThreshold, _, _, _))
186 .WillByDefault(Return(DEFAULT_TIME_TO_ACTIVATE_SECONDS));
187
188 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlActivateTime, _, _, _))
189 .WillByDefault(Return(DEFAULT_TIME_TO_ACTIVATE_SECONDS));
190 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlResumeTime, _, _, _))
191 .WillByDefault(Return(DEFAULT_TIME_TO_CLEAR_SECONDS));
192
193 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlStartSOC, _, _, _))
194 .WillByDefault(Return(70));
195 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlStopSOC, _, _, _))
196 .WillByDefault(Return(80));
197
198 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlTriggerSOC, _, _, _))
199 .WillByDefault(Return(100));
200 }
201
capacityReached(void)202 static void capacityReached(void) {
203 props.batteryLevel = 100;
204 }
205
initToConnectedCapacityReached(void)206 static void initToConnectedCapacityReached(void) {
207 ON_CALL(*mock, ReadFileToString(kPathPersistChargerPresentTime, _, _))
208 .WillByDefault(DoAll(SetArgPointee<1>(std::to_string(1000)), Return(true)));
209 }
210
initToActive(void)211 static void initToActive(void) {
212 ON_CALL(*mock, ReadFileToString(kPathPersistChargerPresentTime, _, _))
213 .WillByDefault(
214 DoAll(SetArgPointee<1>(std::to_string(DEFAULT_TIME_TO_ACTIVATE_SECONDS + 1)),
215 Return(true)));
216 }
217
TEST_F(BatteryDefenderTest,EnableAndDisconnected)218 TEST_F(BatteryDefenderTest, EnableAndDisconnected) {
219 BatteryDefender battDefender;
220
221 enableDefender();
222 // No power
223
224 // Enable Battery Defender
225 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "DISCONNECTED"));
226 battDefender.update(&props);
227 }
228
TEST_F(BatteryDefenderTest,DisableNonDefaultLevels)229 TEST_F(BatteryDefenderTest, DisableNonDefaultLevels) {
230 BatteryDefender battDefender;
231
232 // Enable Battery Defender
233 EXPECT_CALL(*mock, GetIntProperty(kPropChargeLevelVendorStart, _, _, _)).WillOnce(Return(30));
234 EXPECT_CALL(*mock, GetIntProperty(kPropChargeLevelVendorStop, _, _, _)).WillOnce(Return(35));
235
236 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "DISABLED"));
237 battDefender.update(&props);
238 }
239
TEST_F(BatteryDefenderTest,DisableExplicit)240 TEST_F(BatteryDefenderTest, DisableExplicit) {
241 BatteryDefender battDefender;
242
243 // Enable Battery Defender
244 EXPECT_CALL(*mock, GetBoolProperty(kPropBatteryDefenderDisable, _)).WillOnce(Return(true));
245
246 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "DISABLED"));
247 battDefender.update(&props);
248 }
249
TEST_F(BatteryDefenderTest,InitActive)250 TEST_F(BatteryDefenderTest, InitActive) {
251 BatteryDefender battDefender;
252
253 enableDefender();
254 powerAvailable();
255 defaultThresholds();
256
257 EXPECT_CALL(*mock, ReadFileToString(kPathPersistChargerPresentTime, _, _))
258 .WillOnce(DoAll(SetArgPointee<1>(std::to_string(DEFAULT_TIME_TO_ACTIVATE_SECONDS + 1)),
259 Return(true)));
260 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE"));
261 battDefender.update(&props);
262 }
263
TEST_F(BatteryDefenderTest,InitConnectedCapacityReached)264 TEST_F(BatteryDefenderTest, InitConnectedCapacityReached) {
265 BatteryDefender battDefender;
266
267 enableDefender();
268 powerAvailable();
269 defaultThresholds();
270
271 InSequence s;
272
273 int time_expected = DEFAULT_TIME_TO_ACTIVATE_SECONDS - 1;
274 EXPECT_CALL(*mock, ReadFileToString(kPathPersistChargerPresentTime, _, _))
275 .WillOnce(DoAll(SetArgPointee<1>(std::to_string(time_expected)), Return(true)));
276 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
277 battDefender.update(&props);
278
279 testvar_systemTimeSecs += MIN_TIME_BETWEEN_FILE_UPDATES;
280 time_expected += MIN_TIME_BETWEEN_FILE_UPDATES;
281 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(time_expected),
282 kPathPersistChargerPresentTime, _));
283 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE"));
284 battDefender.update(&props);
285 }
286
TEST_F(BatteryDefenderTest,InitConnected)287 TEST_F(BatteryDefenderTest, InitConnected) {
288 BatteryDefender battDefender;
289
290 enableDefender();
291 powerAvailable();
292 defaultThresholds();
293
294 InSequence s;
295
296 EXPECT_CALL(*mock, ReadFileToString(kPathPersistChargerPresentTime, _, _))
297 .WillOnce(DoAll(SetArgPointee<1>(std::to_string(0)), Return(true)));
298 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
299 battDefender.update(&props);
300
301 // mHasReachedHighCapacityLevel shall be false
302 testvar_systemTimeSecs += DEFAULT_TIME_TO_ACTIVATE_SECONDS + 1;
303 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
304 battDefender.update(&props);
305
306 // Would be active if mHasReachedHighCapacityLevel was true
307 testvar_systemTimeSecs += DEFAULT_TIME_TO_ACTIVATE_SECONDS + 1;
308 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
309 battDefender.update(&props);
310 }
311
TEST_F(BatteryDefenderTest,TriggerTime)312 TEST_F(BatteryDefenderTest, TriggerTime) {
313 BatteryDefender battDefender;
314
315 enableDefender();
316 powerAvailable();
317 defaultThresholds();
318
319 InSequence s;
320
321 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
322 testvar_systemTimeSecs += MIN_TIME_BETWEEN_FILE_UPDATES;
323 battDefender.update(&props);
324
325 // Reached 100% capacity at least once
326 capacityReached();
327 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
328 testvar_systemTimeSecs += MIN_TIME_BETWEEN_FILE_UPDATES;
329 battDefender.update(&props);
330
331 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(DEFAULT_TIME_TO_ACTIVATE_SECONDS),
332 kPathPersistChargerPresentTime, _));
333 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
334 testvar_systemTimeSecs += DEFAULT_TIME_TO_ACTIVATE_SECONDS;
335 battDefender.update(&props);
336
337 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(DEFAULT_TIME_TO_ACTIVATE_SECONDS +
338 MIN_TIME_BETWEEN_FILE_UPDATES),
339 kPathPersistChargerPresentTime, _));
340 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE"));
341 testvar_systemTimeSecs += MIN_TIME_BETWEEN_FILE_UPDATES;
342 battDefender.update(&props);
343 }
344
TEST_F(BatteryDefenderTest,ChargeLevels)345 TEST_F(BatteryDefenderTest, ChargeLevels) {
346 BatteryDefender battDefender;
347
348 enableDefender();
349 powerAvailable();
350 defaultThresholds();
351 initToConnectedCapacityReached();
352
353 InSequence s;
354
355 // No expectations needed; default values already set
356 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
357 testvar_systemTimeSecs += 0;
358 battDefender.update(&props);
359
360 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(70), kPathStartLevel, _));
361 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(80), kPathStopLevel, _));
362 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE"));
363 testvar_systemTimeSecs += DEFAULT_TIME_TO_ACTIVATE_SECONDS + 1;
364 battDefender.update(&props);
365 }
366
TEST_F(BatteryDefenderTest,ActiveTime)367 TEST_F(BatteryDefenderTest, ActiveTime) {
368 BatteryDefender battDefender;
369
370 enableDefender();
371 powerAvailable();
372 defaultThresholds();
373 initToActive();
374
375 InSequence s;
376
377 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(70), kPathStartLevel, _));
378 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(80), kPathStopLevel, _));
379 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE"));
380 battDefender.update(&props);
381 }
382
TEST_F(BatteryDefenderTest,ActiveTime_NonDefaultLevels)383 TEST_F(BatteryDefenderTest, ActiveTime_NonDefaultLevels) {
384 BatteryDefender battDefender;
385
386 enableDefender();
387 powerAvailable();
388 initToActive();
389 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderThreshold, _, _, _))
390 .WillByDefault(Return(DEFAULT_TIME_TO_ACTIVATE_SECONDS));
391 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlActivateTime, _, _, _))
392 .WillByDefault(Return(DEFAULT_TIME_TO_ACTIVATE_SECONDS));
393 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlResumeTime, _, _, _))
394 .WillByDefault(Return(DEFAULT_TIME_TO_CLEAR_SECONDS));
395
396 // Non-default
397 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlStartSOC, _, _, _))
398 .WillByDefault(Return(50));
399 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlStopSOC, _, _, _))
400 .WillByDefault(Return(60));
401
402 InSequence s;
403
404 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(50), kPathStartLevel, _));
405 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(60), kPathStopLevel, _));
406 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE"));
407 battDefender.update(&props);
408 }
409
TEST_F(BatteryDefenderTest,ActiveTime_NonDefaultLevels_invalid)410 TEST_F(BatteryDefenderTest, ActiveTime_NonDefaultLevels_invalid) {
411 BatteryDefender battDefender;
412
413 enableDefender();
414 powerAvailable();
415 initToActive();
416 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderThreshold, _, _, _))
417 .WillByDefault(Return(DEFAULT_TIME_TO_ACTIVATE_SECONDS));
418 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlActivateTime, _, _, _))
419 .WillByDefault(Return(DEFAULT_TIME_TO_ACTIVATE_SECONDS));
420 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlResumeTime, _, _, _))
421 .WillByDefault(Return(DEFAULT_TIME_TO_CLEAR_SECONDS));
422
423 // Non-default
424 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlStartSOC, _, _, _))
425 .WillByDefault(Return(30));
426 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlStopSOC, _, _, _))
427 .WillByDefault(Return(10));
428
429 InSequence s;
430
431 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(70), kPathStartLevel, _));
432 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(80), kPathStopLevel, _));
433 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE"));
434 battDefender.update(&props);
435 }
436
TEST_F(BatteryDefenderTest,ConnectDisconnectCycle)437 TEST_F(BatteryDefenderTest, ConnectDisconnectCycle) {
438 BatteryDefender battDefender;
439
440 enableDefender();
441 defaultThresholds();
442 initToConnectedCapacityReached();
443
444 InSequence s;
445
446 // Power ON
447 wirelessPresent();
448
449 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(1000), kPathPersistChargerPresentTime, _));
450 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
451 testvar_systemTimeSecs += 60;
452 battDefender.update(&props);
453
454 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(1060), kPathPersistChargerPresentTime, _));
455 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
456 testvar_systemTimeSecs += 60;
457 battDefender.update(&props);
458
459 // Power OFF
460 wirelessNotPresent();
461
462 // Maintain kPathPersistChargerPresentTime = 1060
463 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
464 testvar_systemTimeSecs += 60;
465 battDefender.update(&props);
466
467 // Maintain kPathPersistChargerPresentTime = 1060
468 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
469 testvar_systemTimeSecs += 60 * 4 - 1;
470 battDefender.update(&props);
471
472 testvar_systemTimeSecs += 1;
473 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(0), kPathPersistChargerPresentTime, _));
474 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "DISCONNECTED"));
475 testvar_systemTimeSecs += MIN_TIME_BETWEEN_FILE_UPDATES;
476 battDefender.update(&props);
477
478 // Power ON
479 wirelessPresent();
480
481 // Maintain kPathPersistChargerPresentTime = 0
482 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
483 testvar_systemTimeSecs += 60;
484 battDefender.update(&props);
485
486 capacityReached();
487 // Maintain kPathPersistChargerPresentTime = 0
488 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
489 testvar_systemTimeSecs += 60;
490 battDefender.update(&props);
491
492 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(60), kPathPersistChargerPresentTime, _));
493 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
494 testvar_systemTimeSecs += 60;
495 battDefender.update(&props);
496 }
497
TEST_F(BatteryDefenderTest,ConnectDisconnectResumeTimeThreshold0)498 TEST_F(BatteryDefenderTest, ConnectDisconnectResumeTimeThreshold0) {
499 BatteryDefender battDefender;
500
501 enableDefender();
502 initToConnectedCapacityReached();
503 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderThreshold, _, _, _))
504 .WillByDefault(Return(DEFAULT_TIME_TO_ACTIVATE_SECONDS));
505 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlActivateTime, _, _, _))
506 .WillByDefault(Return(DEFAULT_TIME_TO_ACTIVATE_SECONDS));
507
508 // Non-default thresholds
509 ON_CALL(*mock, GetIntProperty(kPropBatteryDefenderCtrlResumeTime, _, _, _))
510 .WillByDefault(Return(0));
511
512 InSequence s;
513
514 // Power ON
515 wirelessPresent();
516
517 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(1000), kPathPersistChargerPresentTime, _));
518 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
519 testvar_systemTimeSecs += 60;
520 battDefender.update(&props);
521
522 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(1060), kPathPersistChargerPresentTime, _));
523 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
524 testvar_systemTimeSecs += 60;
525 battDefender.update(&props);
526
527 // Power OFF
528 wirelessNotPresent();
529
530 EXPECT_CALL(*mock, WriteStringToFile(std::to_string(0), kPathPersistChargerPresentTime, _));
531 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "DISCONNECTED"));
532 testvar_systemTimeSecs += MIN_TIME_BETWEEN_FILE_UPDATES;
533 battDefender.update(&props);
534 }
535
TEST_F(BatteryDefenderTest,PropsOverride_InitActive_allOnlineFalse)536 TEST_F(BatteryDefenderTest, PropsOverride_InitActive_allOnlineFalse) {
537 BatteryDefender battDefender;
538
539 enableDefender();
540 usbPresent();
541 defaultThresholds();
542 initToActive();
543
544 InSequence s;
545
546 props.chargerAcOnline = false;
547 props.chargerUsbOnline = false;
548 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE")).Times(2);
549 battDefender.update(&props);
550 ASSERT_EQ(props.chargerAcOnline, false);
551 ASSERT_EQ(props.chargerUsbOnline, true);
552
553 props.chargerAcOnline = false;
554 props.chargerUsbOnline = false;
555 battDefender.update(&props);
556 ASSERT_EQ(props.chargerAcOnline, false);
557 ASSERT_EQ(props.chargerUsbOnline, true);
558 }
559
TEST_F(BatteryDefenderTest,PropsOverride_InitActive_usbOnline)560 TEST_F(BatteryDefenderTest, PropsOverride_InitActive_usbOnline) {
561 BatteryDefender battDefender;
562
563 enableDefender();
564 usbPresent();
565 defaultThresholds();
566 initToActive();
567
568 InSequence s;
569
570 props.chargerAcOnline = false;
571 props.chargerUsbOnline = true;
572 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE")).Times(2);
573 battDefender.update(&props);
574 ASSERT_EQ(props.chargerAcOnline, false);
575 ASSERT_EQ(props.chargerUsbOnline, true);
576
577 props.chargerAcOnline = false;
578 props.chargerUsbOnline = false;
579 battDefender.update(&props);
580 ASSERT_EQ(props.chargerAcOnline, false);
581 ASSERT_EQ(props.chargerUsbOnline, true);
582 }
583
TEST_F(BatteryDefenderTest,PropsOverride_InitActive_acOnline)584 TEST_F(BatteryDefenderTest, PropsOverride_InitActive_acOnline) {
585 BatteryDefender battDefender;
586
587 enableDefender();
588 usbPresent();
589 defaultThresholds();
590 initToActive();
591
592 InSequence s;
593
594 props.chargerAcOnline = true;
595 props.chargerUsbOnline = false;
596 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE")).Times(2);
597 battDefender.update(&props);
598 ASSERT_EQ(props.chargerAcOnline, true);
599 ASSERT_EQ(props.chargerUsbOnline, false);
600
601 props.chargerAcOnline = false;
602 props.chargerUsbOnline = false;
603 battDefender.update(&props);
604 ASSERT_EQ(props.chargerAcOnline, true);
605 ASSERT_EQ(props.chargerUsbOnline, false);
606 }
607
TEST_F(BatteryDefenderTest,PropsOverride_InitActive_allOnline)608 TEST_F(BatteryDefenderTest, PropsOverride_InitActive_allOnline) {
609 BatteryDefender battDefender;
610
611 enableDefender();
612 usbPresent();
613 defaultThresholds();
614 initToActive();
615
616 InSequence s;
617
618 props.chargerAcOnline = true;
619 props.chargerUsbOnline = true;
620 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE")).Times(2);
621 battDefender.update(&props);
622 ASSERT_EQ(props.chargerAcOnline, true);
623 ASSERT_EQ(props.chargerUsbOnline, true);
624
625 props.chargerAcOnline = false;
626 props.chargerUsbOnline = false;
627 battDefender.update(&props);
628 ASSERT_EQ(props.chargerAcOnline, true);
629 ASSERT_EQ(props.chargerUsbOnline, true);
630 }
631
TEST_F(BatteryDefenderTest,PropsOverride_InitConnected_allOnlineFalse)632 TEST_F(BatteryDefenderTest, PropsOverride_InitConnected_allOnlineFalse) {
633 BatteryDefender battDefender;
634
635 enableDefender();
636 usbPresent();
637 defaultThresholds();
638 initToConnectedCapacityReached();
639
640 InSequence s;
641
642 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
643 battDefender.update(&props);
644
645 props.chargerAcOnline = false;
646 props.chargerUsbOnline = false;
647 testvar_systemTimeSecs += DEFAULT_TIME_TO_ACTIVATE_SECONDS + 1;
648 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE")).Times(2);
649 battDefender.update(&props);
650 ASSERT_EQ(props.chargerAcOnline, false);
651 ASSERT_EQ(props.chargerUsbOnline, true);
652
653 props.chargerAcOnline = false;
654 props.chargerUsbOnline = false;
655 battDefender.update(&props);
656 ASSERT_EQ(props.chargerAcOnline, false);
657 ASSERT_EQ(props.chargerUsbOnline, true);
658 }
659
TEST_F(BatteryDefenderTest,PropsOverride_InitConnected_usbOnline)660 TEST_F(BatteryDefenderTest, PropsOverride_InitConnected_usbOnline) {
661 BatteryDefender battDefender;
662
663 enableDefender();
664 usbPresent();
665 defaultThresholds();
666 initToConnectedCapacityReached();
667
668 InSequence s;
669
670 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
671 battDefender.update(&props);
672
673 props.chargerAcOnline = false;
674 props.chargerUsbOnline = true;
675 testvar_systemTimeSecs += DEFAULT_TIME_TO_ACTIVATE_SECONDS + 1;
676 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE")).Times(2);
677 battDefender.update(&props);
678 ASSERT_EQ(props.chargerAcOnline, false);
679 ASSERT_EQ(props.chargerUsbOnline, true);
680
681 props.chargerAcOnline = false;
682 props.chargerUsbOnline = false;
683 battDefender.update(&props);
684 ASSERT_EQ(props.chargerAcOnline, false);
685 ASSERT_EQ(props.chargerUsbOnline, true);
686 }
687
TEST_F(BatteryDefenderTest,PropsOverride_InitConnected_acOnline)688 TEST_F(BatteryDefenderTest, PropsOverride_InitConnected_acOnline) {
689 BatteryDefender battDefender;
690
691 enableDefender();
692 usbPresent();
693 defaultThresholds();
694 initToConnectedCapacityReached();
695
696 InSequence s;
697
698 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
699 battDefender.update(&props);
700
701 props.chargerAcOnline = true;
702 props.chargerUsbOnline = false;
703 testvar_systemTimeSecs += DEFAULT_TIME_TO_ACTIVATE_SECONDS + 1;
704 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE")).Times(2);
705 battDefender.update(&props);
706 ASSERT_EQ(props.chargerAcOnline, true);
707 ASSERT_EQ(props.chargerUsbOnline, false);
708
709 props.chargerAcOnline = false;
710 props.chargerUsbOnline = false;
711 battDefender.update(&props);
712 ASSERT_EQ(props.chargerAcOnline, true);
713 ASSERT_EQ(props.chargerUsbOnline, false);
714 }
715
TEST_F(BatteryDefenderTest,PropsOverride_InitConnected_allOnline)716 TEST_F(BatteryDefenderTest, PropsOverride_InitConnected_allOnline) {
717 BatteryDefender battDefender;
718
719 enableDefender();
720 usbPresent();
721 defaultThresholds();
722 initToConnectedCapacityReached();
723
724 InSequence s;
725
726 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
727 battDefender.update(&props);
728
729 props.chargerAcOnline = true;
730 props.chargerUsbOnline = true;
731 testvar_systemTimeSecs += DEFAULT_TIME_TO_ACTIVATE_SECONDS + 1;
732 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE")).Times(2);
733 battDefender.update(&props);
734 ASSERT_EQ(props.chargerAcOnline, true);
735 ASSERT_EQ(props.chargerUsbOnline, true);
736
737 props.chargerAcOnline = false;
738 props.chargerUsbOnline = false;
739 battDefender.update(&props);
740 ASSERT_EQ(props.chargerAcOnline, true);
741 ASSERT_EQ(props.chargerUsbOnline, true);
742 }
743
TEST_F(BatteryDefenderTest,PropsOverride_InitConnected_overrideHealth)744 TEST_F(BatteryDefenderTest, PropsOverride_InitConnected_overrideHealth) {
745 BatteryDefender battDefender;
746
747 enableDefender();
748 usbPresent();
749 defaultThresholds();
750 initToConnectedCapacityReached();
751
752 InSequence s;
753
754 props.batteryHealth = android::BATTERY_HEALTH_UNKNOWN;
755 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED"));
756 battDefender.update(&props);
757 ASSERT_EQ(props.batteryHealth, android::BATTERY_HEALTH_UNKNOWN);
758
759 props.batteryHealth = android::BATTERY_HEALTH_UNKNOWN;
760 testvar_systemTimeSecs += DEFAULT_TIME_TO_ACTIVATE_SECONDS + 1;
761 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "ACTIVE"));
762 battDefender.update(&props);
763 ASSERT_EQ(props.batteryHealth, android::BATTERY_HEALTH_OVERHEAT);
764 }
765
TEST_F(BatteryDefenderTest,PropsOverride_InitConnected_kernelDefend)766 TEST_F(BatteryDefenderTest, PropsOverride_InitConnected_kernelDefend) {
767 BatteryDefender battDefender;
768
769 enableDefender();
770 usbPresent();
771 defaultThresholds();
772 initToConnectedCapacityReached();
773
774 InSequence s;
775
776 EXPECT_CALL(*mock, SetProperty(kPropBatteryDefenderState, "CONNECTED")).Times(3);
777 battDefender.update(&props);
778
779 props.chargerAcOnline = true;
780 props.chargerUsbOnline = true;
781 props.batteryHealth = android::BATTERY_HEALTH_OVERHEAT;
782 battDefender.update(&props);
783 ASSERT_EQ(props.chargerAcOnline, true);
784 ASSERT_EQ(props.chargerUsbOnline, true);
785
786 props.chargerAcOnline = false;
787 props.chargerUsbOnline = false;
788 battDefender.update(&props);
789 ASSERT_EQ(props.chargerAcOnline, true);
790 ASSERT_EQ(props.chargerUsbOnline, true);
791 }
792
793 } // namespace health
794 } // namespace pixel
795 } // namespace google
796 } // namespace hardware
797