OLD | NEW |
| (Empty) |
1 #!/usr/bin/env python | |
2 # Copyright 2014 The Chromium Authors. All rights reserved. | |
3 # Use of this source code is governed by a BSD-style license that can be | |
4 # found in the LICENSE file. | |
5 | |
6 """ | |
7 Unit tests for the contents of battery_utils.py | |
8 """ | |
9 | |
10 # pylint: disable=W0613 | |
11 | |
12 import logging | |
13 import os | |
14 import sys | |
15 import unittest | |
16 | |
17 from pylib import constants | |
18 from pylib.device import battery_utils | |
19 from pylib.device import device_errors | |
20 from pylib.device import device_utils | |
21 from pylib.device import device_utils_test | |
22 from pylib.utils import mock_calls | |
23 | |
24 sys.path.append(os.path.join( | |
25 constants.DIR_SOURCE_ROOT, 'third_party', 'pymock')) | |
26 import mock # pylint: disable=F0401 | |
27 | |
28 _DUMPSYS_OUTPUT = [ | |
29 '9,0,i,uid,1000,test_package1', | |
30 '9,0,i,uid,1001,test_package2', | |
31 '9,1000,l,pwi,uid,1', | |
32 '9,1001,l,pwi,uid,2', | |
33 '9,0,l,pws,1728,2000,190,207', | |
34 ] | |
35 | |
36 | |
37 class BatteryUtilsTest(mock_calls.TestCase): | |
38 | |
39 _NEXUS_5 = { | |
40 'name': 'Nexus 5', | |
41 'witness_file': '/sys/kernel/debug/bq24192/INPUT_SRC_CONT', | |
42 'enable_command': ( | |
43 'echo 0x4A > /sys/kernel/debug/bq24192/INPUT_SRC_CONT && ' | |
44 'echo 1 > /sys/class/power_supply/usb/online'), | |
45 'disable_command': ( | |
46 'echo 0xCA > /sys/kernel/debug/bq24192/INPUT_SRC_CONT && ' | |
47 'chmod 644 /sys/class/power_supply/usb/online && ' | |
48 'echo 0 > /sys/class/power_supply/usb/online'), | |
49 'charge_counter': None, | |
50 'voltage': None, | |
51 'current': None, | |
52 } | |
53 | |
54 _NEXUS_6 = { | |
55 'name': 'Nexus 6', | |
56 'witness_file': None, | |
57 'enable_command': None, | |
58 'disable_command': None, | |
59 'charge_counter': ( | |
60 '/sys/class/power_supply/max170xx_battery/charge_counter_ext'), | |
61 'voltage': '/sys/class/power_supply/max170xx_battery/voltage_now', | |
62 'current': '/sys/class/power_supply/max170xx_battery/current_now', | |
63 } | |
64 | |
65 _NEXUS_10 = { | |
66 'name': 'Nexus 10', | |
67 'witness_file': None, | |
68 'enable_command': None, | |
69 'disable_command': None, | |
70 'charge_counter': ( | |
71 '/sys/class/power_supply/ds2784-fuelgauge/charge_counter_ext'), | |
72 'voltage': '/sys/class/power_supply/ds2784-fuelgauge/voltage_now', | |
73 'current': '/sys/class/power_supply/ds2784-fuelgauge/current_now', | |
74 } | |
75 | |
76 def ShellError(self, output=None, status=1): | |
77 def action(cmd, *args, **kwargs): | |
78 raise device_errors.AdbShellCommandFailedError( | |
79 cmd, output, status, str(self.device)) | |
80 if output is None: | |
81 output = 'Permission denied\n' | |
82 return action | |
83 | |
84 def setUp(self): | |
85 self.adb = device_utils_test._AdbWrapperMock('0123456789abcdef') | |
86 self.device = device_utils.DeviceUtils( | |
87 self.adb, default_timeout=10, default_retries=0) | |
88 self.watchMethodCalls(self.call.adb, ignore=['GetDeviceSerial']) | |
89 self.battery = battery_utils.BatteryUtils( | |
90 self.device, default_timeout=10, default_retries=0) | |
91 | |
92 | |
93 class BatteryUtilsInitTest(unittest.TestCase): | |
94 | |
95 def testInitWithDeviceUtil(self): | |
96 serial = '0fedcba987654321' | |
97 d = device_utils.DeviceUtils(serial) | |
98 b = battery_utils.BatteryUtils(d) | |
99 self.assertEqual(d, b._device) | |
100 | |
101 def testInitWithMissing_fails(self): | |
102 with self.assertRaises(TypeError): | |
103 battery_utils.BatteryUtils(None) | |
104 with self.assertRaises(TypeError): | |
105 battery_utils.BatteryUtils('') | |
106 | |
107 | |
108 class BatteryUtilsSetChargingTest(BatteryUtilsTest): | |
109 | |
110 @mock.patch('time.sleep', mock.Mock()) | |
111 def testSetCharging_enabled(self): | |
112 self.battery._cache['profile'] = self._NEXUS_5 | |
113 with self.assertCalls( | |
114 (self.call.device.RunShellCommand( | |
115 mock.ANY, check_return=True, as_root=True, large_output=True), []), | |
116 (self.call.battery.GetCharging(), False), | |
117 (self.call.battery.GetCharging(), True)): | |
118 self.battery.SetCharging(True) | |
119 | |
120 def testSetCharging_alreadyEnabled(self): | |
121 self.battery._cache['profile'] = self._NEXUS_5 | |
122 with self.assertCalls( | |
123 (self.call.device.RunShellCommand( | |
124 mock.ANY, check_return=True, as_root=True, large_output=True), []), | |
125 (self.call.battery.GetCharging(), True)): | |
126 self.battery.SetCharging(True) | |
127 | |
128 @mock.patch('time.sleep', mock.Mock()) | |
129 def testSetCharging_disabled(self): | |
130 self.battery._cache['profile'] = self._NEXUS_5 | |
131 with self.assertCalls( | |
132 (self.call.device.RunShellCommand( | |
133 mock.ANY, check_return=True, as_root=True, large_output=True), []), | |
134 (self.call.battery.GetCharging(), True), | |
135 (self.call.battery.GetCharging(), False)): | |
136 self.battery.SetCharging(False) | |
137 | |
138 | |
139 class BatteryUtilsSetBatteryMeasurementTest(BatteryUtilsTest): | |
140 | |
141 @mock.patch('time.sleep', mock.Mock()) | |
142 def testBatteryMeasurementWifi(self): | |
143 with self.assertCalls( | |
144 (self.call.device.RunShellCommand( | |
145 mock.ANY, retries=0, single_line=True, | |
146 timeout=10, check_return=True), '22'), | |
147 (self.call.battery._ClearPowerData(), True), | |
148 (self.call.device.RunShellCommand( | |
149 ['dumpsys', 'battery', 'set', 'ac', '0'], check_return=True), []), | |
150 (self.call.device.RunShellCommand( | |
151 ['dumpsys', 'battery', 'set', 'usb', '0'], check_return=True), []), | |
152 (self.call.battery.GetCharging(), False), | |
153 (self.call.device.RunShellCommand( | |
154 ['dumpsys', 'battery', 'reset'], check_return=True), []), | |
155 (self.call.battery.GetCharging(), False), | |
156 (self.call.device.RunShellCommand( | |
157 ['dumpsys', 'battery'], check_return=True), ['UPDATES STOPPED']), | |
158 (self.call.battery.GetCharging(), False), | |
159 (self.call.device.RunShellCommand( | |
160 ['dumpsys', 'battery'], check_return=True), [])): | |
161 with self.battery.BatteryMeasurement(): | |
162 pass | |
163 | |
164 @mock.patch('time.sleep', mock.Mock()) | |
165 def testBatteryMeasurementUsb(self): | |
166 with self.assertCalls( | |
167 (self.call.device.RunShellCommand( | |
168 mock.ANY, retries=0, single_line=True, | |
169 timeout=10, check_return=True), '22'), | |
170 (self.call.battery._ClearPowerData(), True), | |
171 (self.call.device.RunShellCommand( | |
172 ['dumpsys', 'battery', 'set', 'ac', '0'], check_return=True), []), | |
173 (self.call.device.RunShellCommand( | |
174 ['dumpsys', 'battery', 'set', 'usb', '0'], check_return=True), []), | |
175 (self.call.battery.GetCharging(), False), | |
176 (self.call.device.RunShellCommand( | |
177 ['dumpsys', 'battery', 'reset'], check_return=True), []), | |
178 (self.call.battery.GetCharging(), False), | |
179 (self.call.device.RunShellCommand( | |
180 ['dumpsys', 'battery'], check_return=True), ['UPDATES STOPPED']), | |
181 (self.call.battery.GetCharging(), True)): | |
182 with self.battery.BatteryMeasurement(): | |
183 pass | |
184 | |
185 | |
186 class BatteryUtilsGetPowerData(BatteryUtilsTest): | |
187 | |
188 def testGetPowerData(self): | |
189 with self.assertCalls( | |
190 (self.call.device.RunShellCommand( | |
191 ['dumpsys', 'batterystats', '-c'], | |
192 check_return=True, large_output=True), | |
193 _DUMPSYS_OUTPUT)): | |
194 data = self.battery.GetPowerData() | |
195 check = { | |
196 'system_total': 2000.0, | |
197 'per_package': { | |
198 'test_package1': {'uid': '1000', 'data': [1.0]}, | |
199 'test_package2': {'uid': '1001', 'data': [2.0]} | |
200 } | |
201 } | |
202 self.assertEqual(data, check) | |
203 | |
204 def testGetPowerData_packageCollisionSame(self): | |
205 self.battery._cache['uids'] = {'test_package1': '1000'} | |
206 with self.assertCall( | |
207 self.call.device.RunShellCommand( | |
208 ['dumpsys', 'batterystats', '-c'], | |
209 check_return=True, large_output=True), | |
210 _DUMPSYS_OUTPUT): | |
211 data = self.battery.GetPowerData() | |
212 check = { | |
213 'system_total': 2000.0, | |
214 'per_package': { | |
215 'test_package1': {'uid': '1000', 'data': [1.0]}, | |
216 'test_package2': {'uid': '1001', 'data': [2.0]} | |
217 } | |
218 } | |
219 self.assertEqual(data, check) | |
220 | |
221 def testGetPowerData_packageCollisionDifferent(self): | |
222 self.battery._cache['uids'] = {'test_package1': '1'} | |
223 with self.assertCall( | |
224 self.call.device.RunShellCommand( | |
225 ['dumpsys', 'batterystats', '-c'], | |
226 check_return=True, large_output=True), | |
227 _DUMPSYS_OUTPUT): | |
228 with self.assertRaises(device_errors.CommandFailedError): | |
229 self.battery.GetPowerData() | |
230 | |
231 def testGetPowerData_cacheCleared(self): | |
232 with self.assertCalls( | |
233 (self.call.device.RunShellCommand( | |
234 ['dumpsys', 'batterystats', '-c'], | |
235 check_return=True, large_output=True), | |
236 _DUMPSYS_OUTPUT)): | |
237 self.battery._cache.clear() | |
238 data = self.battery.GetPowerData() | |
239 check = { | |
240 'system_total': 2000.0, | |
241 'per_package': { | |
242 'test_package1': {'uid': '1000', 'data': [1.0]}, | |
243 'test_package2': {'uid': '1001', 'data': [2.0]} | |
244 } | |
245 } | |
246 self.assertEqual(data, check) | |
247 | |
248 | |
249 class BatteryUtilsChargeDevice(BatteryUtilsTest): | |
250 | |
251 @mock.patch('time.sleep', mock.Mock()) | |
252 def testChargeDeviceToLevel(self): | |
253 with self.assertCalls( | |
254 (self.call.battery.SetCharging(True)), | |
255 (self.call.battery.GetBatteryInfo(), {'level': '50'}), | |
256 (self.call.battery.GetBatteryInfo(), {'level': '100'})): | |
257 self.battery.ChargeDeviceToLevel(95) | |
258 | |
259 | |
260 class BatteryUtilsDischargeDevice(BatteryUtilsTest): | |
261 | |
262 @mock.patch('time.sleep', mock.Mock()) | |
263 def testDischargeDevice_exact(self): | |
264 with self.assertCalls( | |
265 (self.call.battery.GetBatteryInfo(), {'level': '100'}), | |
266 (self.call.battery.SetCharging(False)), | |
267 (self.call.battery.SetCharging(True)), | |
268 (self.call.battery.GetBatteryInfo(), {'level': '99'})): | |
269 self.battery._DischargeDevice(1) | |
270 | |
271 @mock.patch('time.sleep', mock.Mock()) | |
272 def testDischargeDevice_over(self): | |
273 with self.assertCalls( | |
274 (self.call.battery.GetBatteryInfo(), {'level': '100'}), | |
275 (self.call.battery.SetCharging(False)), | |
276 (self.call.battery.SetCharging(True)), | |
277 (self.call.battery.GetBatteryInfo(), {'level': '50'})): | |
278 self.battery._DischargeDevice(1) | |
279 | |
280 @mock.patch('time.sleep', mock.Mock()) | |
281 def testDischargeDevice_takeslong(self): | |
282 with self.assertCalls( | |
283 (self.call.battery.GetBatteryInfo(), {'level': '100'}), | |
284 (self.call.battery.SetCharging(False)), | |
285 (self.call.battery.SetCharging(True)), | |
286 (self.call.battery.GetBatteryInfo(), {'level': '100'}), | |
287 (self.call.battery.SetCharging(False)), | |
288 (self.call.battery.SetCharging(True)), | |
289 (self.call.battery.GetBatteryInfo(), {'level': '99'}), | |
290 (self.call.battery.SetCharging(False)), | |
291 (self.call.battery.SetCharging(True)), | |
292 (self.call.battery.GetBatteryInfo(), {'level': '98'}), | |
293 (self.call.battery.SetCharging(False)), | |
294 (self.call.battery.SetCharging(True)), | |
295 (self.call.battery.GetBatteryInfo(), {'level': '97'})): | |
296 self.battery._DischargeDevice(3) | |
297 | |
298 @mock.patch('time.sleep', mock.Mock()) | |
299 def testDischargeDevice_dischargeTooClose(self): | |
300 with self.assertCalls( | |
301 (self.call.battery.GetBatteryInfo(), {'level': '100'})): | |
302 self.battery._DischargeDevice(99) | |
303 | |
304 @mock.patch('time.sleep', mock.Mock()) | |
305 def testDischargeDevice_percentageOutOfBounds(self): | |
306 with self.assertCalls( | |
307 (self.call.battery.GetBatteryInfo(), {'level': '100'})): | |
308 with self.assertRaises(ValueError): | |
309 self.battery._DischargeDevice(100) | |
310 with self.assertCalls( | |
311 (self.call.battery.GetBatteryInfo(), {'level': '100'})): | |
312 with self.assertRaises(ValueError): | |
313 self.battery._DischargeDevice(0) | |
314 | |
315 | |
316 class BatteryUtilsGetBatteryInfoTest(BatteryUtilsTest): | |
317 | |
318 def testGetBatteryInfo_normal(self): | |
319 with self.assertCall( | |
320 self.call.device.RunShellCommand( | |
321 ['dumpsys', 'battery'], check_return=True), | |
322 [ | |
323 'Current Battery Service state:', | |
324 ' AC powered: false', | |
325 ' USB powered: true', | |
326 ' level: 100', | |
327 ' temperature: 321', | |
328 ]): | |
329 self.assertEquals( | |
330 { | |
331 'AC powered': 'false', | |
332 'USB powered': 'true', | |
333 'level': '100', | |
334 'temperature': '321', | |
335 }, | |
336 self.battery.GetBatteryInfo()) | |
337 | |
338 def testGetBatteryInfo_nothing(self): | |
339 with self.assertCall( | |
340 self.call.device.RunShellCommand( | |
341 ['dumpsys', 'battery'], check_return=True), []): | |
342 self.assertEquals({}, self.battery.GetBatteryInfo()) | |
343 | |
344 | |
345 class BatteryUtilsGetChargingTest(BatteryUtilsTest): | |
346 | |
347 def testGetCharging_usb(self): | |
348 with self.assertCall( | |
349 self.call.battery.GetBatteryInfo(), {'USB powered': 'true'}): | |
350 self.assertTrue(self.battery.GetCharging()) | |
351 | |
352 def testGetCharging_usbFalse(self): | |
353 with self.assertCall( | |
354 self.call.battery.GetBatteryInfo(), {'USB powered': 'false'}): | |
355 self.assertFalse(self.battery.GetCharging()) | |
356 | |
357 def testGetCharging_ac(self): | |
358 with self.assertCall( | |
359 self.call.battery.GetBatteryInfo(), {'AC powered': 'true'}): | |
360 self.assertTrue(self.battery.GetCharging()) | |
361 | |
362 def testGetCharging_wireless(self): | |
363 with self.assertCall( | |
364 self.call.battery.GetBatteryInfo(), {'Wireless powered': 'true'}): | |
365 self.assertTrue(self.battery.GetCharging()) | |
366 | |
367 def testGetCharging_unknown(self): | |
368 with self.assertCall( | |
369 self.call.battery.GetBatteryInfo(), {'level': '42'}): | |
370 self.assertFalse(self.battery.GetCharging()) | |
371 | |
372 | |
373 class BatteryUtilsGetNetworkDataTest(BatteryUtilsTest): | |
374 | |
375 def testGetNetworkData_noDataUsage(self): | |
376 with self.assertCalls( | |
377 (self.call.device.RunShellCommand( | |
378 ['dumpsys', 'batterystats', '-c'], | |
379 check_return=True, large_output=True), | |
380 _DUMPSYS_OUTPUT), | |
381 (self.call.device.ReadFile('/proc/uid_stat/1000/tcp_snd'), | |
382 self.ShellError()), | |
383 (self.call.device.ReadFile('/proc/uid_stat/1000/tcp_rcv'), | |
384 self.ShellError())): | |
385 self.assertEquals(self.battery.GetNetworkData('test_package1'), (0, 0)) | |
386 | |
387 def testGetNetworkData_badPackage(self): | |
388 with self.assertCall( | |
389 self.call.device.RunShellCommand( | |
390 ['dumpsys', 'batterystats', '-c'], | |
391 check_return=True, large_output=True), | |
392 _DUMPSYS_OUTPUT): | |
393 self.assertEqual(self.battery.GetNetworkData('asdf'), None) | |
394 | |
395 def testGetNetworkData_packageNotCached(self): | |
396 with self.assertCalls( | |
397 (self.call.device.RunShellCommand( | |
398 ['dumpsys', 'batterystats', '-c'], | |
399 check_return=True, large_output=True), | |
400 _DUMPSYS_OUTPUT), | |
401 (self.call.device.ReadFile('/proc/uid_stat/1000/tcp_snd'), 1), | |
402 (self.call.device.ReadFile('/proc/uid_stat/1000/tcp_rcv'), 2)): | |
403 self.assertEqual(self.battery.GetNetworkData('test_package1'), (1,2)) | |
404 | |
405 def testGetNetworkData_packageCached(self): | |
406 self.battery._cache['uids'] = {'test_package1': '1000'} | |
407 with self.assertCalls( | |
408 (self.call.device.ReadFile('/proc/uid_stat/1000/tcp_snd'), 1), | |
409 (self.call.device.ReadFile('/proc/uid_stat/1000/tcp_rcv'), 2)): | |
410 self.assertEqual(self.battery.GetNetworkData('test_package1'), (1,2)) | |
411 | |
412 def testGetNetworkData_clearedCache(self): | |
413 with self.assertCalls( | |
414 (self.call.device.RunShellCommand( | |
415 ['dumpsys', 'batterystats', '-c'], | |
416 check_return=True, large_output=True), | |
417 _DUMPSYS_OUTPUT), | |
418 (self.call.device.ReadFile('/proc/uid_stat/1000/tcp_snd'), 1), | |
419 (self.call.device.ReadFile('/proc/uid_stat/1000/tcp_rcv'), 2)): | |
420 self.battery._cache.clear() | |
421 self.assertEqual(self.battery.GetNetworkData('test_package1'), (1,2)) | |
422 | |
423 | |
424 class BatteryUtilsLetBatteryCoolToTemperatureTest(BatteryUtilsTest): | |
425 | |
426 @mock.patch('time.sleep', mock.Mock()) | |
427 def testLetBatteryCoolToTemperature_startUnder(self): | |
428 self.battery._cache['profile'] = self._NEXUS_6 | |
429 with self.assertCalls( | |
430 (self.call.battery.EnableBatteryUpdates(), []), | |
431 (self.call.battery.GetBatteryInfo(), {'temperature': '500'})): | |
432 self.battery.LetBatteryCoolToTemperature(600) | |
433 | |
434 @mock.patch('time.sleep', mock.Mock()) | |
435 def testLetBatteryCoolToTemperature_startOver(self): | |
436 self.battery._cache['profile'] = self._NEXUS_6 | |
437 with self.assertCalls( | |
438 (self.call.battery.EnableBatteryUpdates(), []), | |
439 (self.call.battery.GetBatteryInfo(), {'temperature': '500'}), | |
440 (self.call.battery.GetBatteryInfo(), {'temperature': '400'})): | |
441 self.battery.LetBatteryCoolToTemperature(400) | |
442 | |
443 @mock.patch('time.sleep', mock.Mock()) | |
444 def testLetBatteryCoolToTemperature_nexus5Hot(self): | |
445 self.battery._cache['profile'] = self._NEXUS_5 | |
446 with self.assertCalls( | |
447 (self.call.battery.EnableBatteryUpdates(), []), | |
448 (self.call.battery.GetBatteryInfo(), {'temperature': '500'}), | |
449 (self.call.battery._DischargeDevice(1), []), | |
450 (self.call.battery.GetBatteryInfo(), {'temperature': '400'})): | |
451 self.battery.LetBatteryCoolToTemperature(400) | |
452 | |
453 @mock.patch('time.sleep', mock.Mock()) | |
454 def testLetBatteryCoolToTemperature_nexus5Cool(self): | |
455 self.battery._cache['profile'] = self._NEXUS_5 | |
456 with self.assertCalls( | |
457 (self.call.battery.EnableBatteryUpdates(), []), | |
458 (self.call.battery.GetBatteryInfo(), {'temperature': '400'})): | |
459 self.battery.LetBatteryCoolToTemperature(400) | |
460 | |
461 | |
462 class BatteryUtilsSupportsFuelGaugeTest(BatteryUtilsTest): | |
463 | |
464 def testSupportsFuelGauge_false(self): | |
465 self.battery._cache['profile'] = self._NEXUS_5 | |
466 self.assertFalse(self.battery.SupportsFuelGauge()) | |
467 | |
468 def testSupportsFuelGauge_trueMax(self): | |
469 self.battery._cache['profile'] = self._NEXUS_6 | |
470 # TODO(rnephew): Change this to assertTrue when we have support for | |
471 # disabling hardware charging on nexus 6. | |
472 self.assertFalse(self.battery.SupportsFuelGauge()) | |
473 | |
474 def testSupportsFuelGauge_trueDS(self): | |
475 self.battery._cache['profile'] = self._NEXUS_10 | |
476 # TODO(rnephew): Change this to assertTrue when we have support for | |
477 # disabling hardware charging on nexus 10. | |
478 self.assertFalse(self.battery.SupportsFuelGauge()) | |
479 | |
480 | |
481 class BatteryUtilsGetFuelGaugeChargeCounterTest(BatteryUtilsTest): | |
482 | |
483 def testGetFuelGaugeChargeCounter_noFuelGauge(self): | |
484 self.battery._cache['profile'] = self._NEXUS_5 | |
485 with self.assertRaises(device_errors.CommandFailedError): | |
486 self.battery.GetFuelGaugeChargeCounter() | |
487 | |
488 def testGetFuelGaugeChargeCounter_fuelGaugePresent(self): | |
489 self.battery._cache['profile']= self._NEXUS_6 | |
490 with self.assertCalls( | |
491 (self.call.battery.SupportsFuelGauge(), True), | |
492 (self.call.device.ReadFile(mock.ANY), '123')): | |
493 self.assertEqual(self.battery.GetFuelGaugeChargeCounter(), 123) | |
494 | |
495 | |
496 class BatteryUtilsTieredSetCharging(BatteryUtilsTest): | |
497 | |
498 @mock.patch('time.sleep', mock.Mock()) | |
499 def testTieredSetCharging_softwareSetTrue(self): | |
500 self.battery._cache['profile'] = self._NEXUS_6 | |
501 with self.assertCalls( | |
502 (self.call.battery.GetCharging(), False), | |
503 (self.call.device.RunShellCommand( | |
504 ['dumpsys', 'battery', 'reset'], check_return=True), []), | |
505 (self.call.battery.GetCharging(), False), | |
506 (self.call.device.RunShellCommand( | |
507 ['dumpsys', 'battery'], check_return=True), ['UPDATES STOPPED']), | |
508 (self.call.battery.GetCharging(), True)): | |
509 self.battery.TieredSetCharging(True) | |
510 | |
511 @mock.patch('time.sleep', mock.Mock()) | |
512 def testTieredSetCharging_softwareSetFalse(self): | |
513 self.battery._cache['profile'] = self._NEXUS_6 | |
514 with self.assertCalls( | |
515 (self.call.battery.GetCharging(), True), | |
516 (self.call.battery._ClearPowerData(), True), | |
517 (self.call.device.RunShellCommand( | |
518 ['dumpsys', 'battery', 'set', 'ac', '0'], check_return=True), []), | |
519 (self.call.device.RunShellCommand( | |
520 ['dumpsys', 'battery', 'set', 'usb', '0'], check_return=True), []), | |
521 (self.call.battery.GetCharging(), False)): | |
522 self.battery.TieredSetCharging(False) | |
523 | |
524 @mock.patch('time.sleep', mock.Mock()) | |
525 def testTieredSetCharging_hardwareSetTrue(self): | |
526 self.battery._cache['profile'] = self._NEXUS_5 | |
527 with self.assertCalls( | |
528 (self.call.battery.GetCharging(), False), | |
529 (self.call.battery.SetCharging(True))): | |
530 self.battery.TieredSetCharging(True) | |
531 | |
532 @mock.patch('time.sleep', mock.Mock()) | |
533 def testTieredSetCharging_hardwareSetFalse(self): | |
534 self.battery._cache['profile'] = self._NEXUS_5 | |
535 with self.assertCalls( | |
536 (self.call.battery.GetCharging(), True), | |
537 (self.call.battery._ClearPowerData(), True), | |
538 (self.call.battery.SetCharging(False))): | |
539 self.battery.TieredSetCharging(False) | |
540 | |
541 def testTieredSetCharging_expectedStateAlreadyTrue(self): | |
542 with self.assertCalls((self.call.battery.GetCharging(), True)): | |
543 self.battery.TieredSetCharging(True) | |
544 | |
545 def testTieredSetCharging_expectedStateAlreadyFalse(self): | |
546 with self.assertCalls((self.call.battery.GetCharging(), False)): | |
547 self.battery.TieredSetCharging(False) | |
548 | |
549 | |
550 class BatteryUtilsPowerMeasurement(BatteryUtilsTest): | |
551 | |
552 def testPowerMeasurement_hardware(self): | |
553 self.battery._cache['profile'] = self._NEXUS_5 | |
554 with self.assertCalls( | |
555 (self.call.battery.GetCharging(), True), | |
556 (self.call.battery._ClearPowerData(), True), | |
557 (self.call.battery.SetCharging(False)), | |
558 (self.call.battery.GetCharging(), False), | |
559 (self.call.battery.SetCharging(True))): | |
560 with self.battery.PowerMeasurement(): | |
561 pass | |
562 | |
563 @mock.patch('time.sleep', mock.Mock()) | |
564 def testPowerMeasurement_software(self): | |
565 self.battery._cache['profile'] = self._NEXUS_6 | |
566 with self.assertCalls( | |
567 (self.call.battery.GetCharging(), True), | |
568 (self.call.battery._ClearPowerData(), True), | |
569 (self.call.device.RunShellCommand( | |
570 ['dumpsys', 'battery', 'set', 'ac', '0'], check_return=True), []), | |
571 (self.call.device.RunShellCommand( | |
572 ['dumpsys', 'battery', 'set', 'usb', '0'], check_return=True), []), | |
573 (self.call.battery.GetCharging(), False), | |
574 (self.call.battery.GetCharging(), False), | |
575 (self.call.device.RunShellCommand( | |
576 ['dumpsys', 'battery', 'reset'], check_return=True), []), | |
577 (self.call.battery.GetCharging(), False), | |
578 (self.call.device.RunShellCommand( | |
579 ['dumpsys', 'battery'], check_return=True), ['UPDATES STOPPED']), | |
580 (self.call.battery.GetCharging(), True)): | |
581 with self.battery.PowerMeasurement(): | |
582 pass | |
583 | |
584 | |
585 class BatteryUtilsDiscoverDeviceProfile(BatteryUtilsTest): | |
586 | |
587 def testDiscoverDeviceProfile_known(self): | |
588 with self.assertCalls( | |
589 (self.call.adb.Shell('getprop ro.product.model'), "Nexus 4")): | |
590 self.battery._DiscoverDeviceProfile() | |
591 self.assertEqual(self.battery._cache['profile']['name'], "Nexus 4") | |
592 | |
593 def testDiscoverDeviceProfile_unknown(self): | |
594 with self.assertCalls( | |
595 (self.call.adb.Shell('getprop ro.product.model'), "Other")): | |
596 self.battery._DiscoverDeviceProfile() | |
597 self.assertEqual(self.battery._cache['profile']['name'], None) | |
598 | |
599 | |
600 class BatteryUtilsClearPowerData(BatteryUtilsTest): | |
601 | |
602 def testClearPowerData_preL(self): | |
603 with self.assertCalls( | |
604 (self.call.device.RunShellCommand(mock.ANY, retries=0, | |
605 single_line=True, timeout=10, check_return=True), '20')): | |
606 self.assertFalse(self.battery._ClearPowerData()) | |
607 | |
608 def testClearPowerData_clearedL(self): | |
609 with self.assertCalls( | |
610 (self.call.device.RunShellCommand(mock.ANY, retries=0, | |
611 single_line=True, timeout=10, check_return=True), '22'), | |
612 (self.call.device.RunShellCommand( | |
613 ['dumpsys', 'battery', 'set', 'usb', '1'], check_return=True), []), | |
614 (self.call.device.RunShellCommand( | |
615 ['dumpsys', 'battery', 'set', 'ac', '1'], check_return=True), []), | |
616 (self.call.device.RunShellCommand( | |
617 ['dumpsys', 'batterystats', '--reset'], check_return=True), []), | |
618 (self.call.device.RunShellCommand( | |
619 ['dumpsys', 'batterystats', '--charged', '-c'], | |
620 check_return=True, large_output=True), []), | |
621 (self.call.device.RunShellCommand( | |
622 ['dumpsys', 'battery', 'reset'], check_return=True), [])): | |
623 self.assertTrue(self.battery._ClearPowerData()) | |
624 | |
625 def testClearPowerData_notClearedL(self): | |
626 with self.assertCalls( | |
627 (self.call.device.RunShellCommand(mock.ANY, retries=0, | |
628 single_line=True, timeout=10, check_return=True), '22'), | |
629 (self.call.device.RunShellCommand( | |
630 ['dumpsys', 'battery', 'set', 'usb', '1'], check_return=True), []), | |
631 (self.call.device.RunShellCommand( | |
632 ['dumpsys', 'battery', 'set', 'ac', '1'], check_return=True), []), | |
633 (self.call.device.RunShellCommand( | |
634 ['dumpsys', 'batterystats', '--reset'], check_return=True), []), | |
635 (self.call.device.RunShellCommand( | |
636 ['dumpsys', 'batterystats', '--charged', '-c'], | |
637 check_return=True, large_output=True), | |
638 ['9,1000,l,pwi,uid,0.0327']), | |
639 (self.call.device.RunShellCommand( | |
640 ['dumpsys', 'battery', 'reset'], check_return=True), [])): | |
641 with self.assertRaises(device_errors.CommandFailedError): | |
642 self.battery._ClearPowerData() | |
643 | |
644 | |
645 if __name__ == '__main__': | |
646 logging.getLogger().setLevel(logging.DEBUG) | |
647 unittest.main(verbosity=2) | |
OLD | NEW |