xref: /aosp_15_r20/cts/hostsidetests/dumpsys/src/android/dumpsys/cts/BatteryStatsDumpsysTest.java (revision b7c941bb3fa97aba169d73cee0bed2de8ac964bf) 
1 /*
2  * Copyright (C) 2017 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 package android.dumpsys.cts;
18 
19 import static com.google.common.truth.Truth.assertThat;
20 
21 import com.android.tradefed.log.LogUtil.CLog;
22 
23 import java.io.BufferedReader;
24 import java.io.StringReader;
25 import java.util.ArrayList;
26 import java.util.HashSet;
27 import java.util.Set;
28 
29 /**
30  * Test to check the format of the dumps of the batterystats test.
31  */
32 public class BatteryStatsDumpsysTest extends BaseDumpsysTest {
33    private static final String TEST_APK = "CtsFramestatsTestApp.apk";
34     private static final String TEST_PKG = "com.android.cts.framestatstestapp";
35 
36     /**
37      * Parse each line from output of dumpsys to handle special fields such as
38      * 'aaa,"bbb,ccc",ddd', to capture properly.
39      */
parseCsv(String line)40     private static String[] parseCsv(String line) {
41         ArrayList<String> parts = new ArrayList<>();
42         String[] splitStrings = line.split(",", -1);
43         String s = "";
44         boolean escaping = false;
45         for (String splitString : splitStrings) {
46             if (escaping) {
47                 s += "," + splitString;
48             } else {
49                 if (splitString.startsWith("\"")) {
50                     // Field start with ". Start escaping.
51                     s = splitString;
52                     escaping = true;
53                 } else {
54                     parts.add(splitString);
55                 }
56             }
57             if (escaping && s.length() > 1 && s.endsWith("\"")) {
58                 // Field end with ". Stop escaping.
59                 parts.add(s.substring(1, s.length() - 1));
60                 escaping = false;
61             }
62         }
63         if (escaping) {
64             // Unclosed escaping string. Add it anyway.
65             parts.add(s.substring(1));
66         }
67 
68         return parts.toArray(new String[parts.size()]);
69     }
70 
71     /**
72      * Tests the output of "dumpsys batterystats --checkin".
73      *
74      * @throws Exception
75      */
testBatterystatsOutput()76     public void testBatterystatsOutput() throws Exception {
77         String batterystats = mDevice.executeShellCommand("dumpsys batterystats --checkin");
78         assertNotNull(batterystats);
79         assertTrue(batterystats.length() > 0);
80 
81         Set<String> seenTags = new HashSet<>();
82 
83         try (BufferedReader reader = new BufferedReader(
84                 new StringReader(batterystats))) {
85 
86             String line;
87             while ((line = reader.readLine()) != null) {
88                 if (line.isEmpty()) {
89                     continue;
90                 }
91 
92 
93                 try {
94                     String[] parts = parseCsv(line);
95                     assertInteger(parts[0]); // old version
96                     assertInteger(parts[1]); // UID
97                     switch (parts[2]) { // aggregation type
98                         case "i":
99                         case "l":
100                         case "c":
101                         case "u":
102                             break;
103                         default:
104                             fail("malformed stat: " + parts[2]);
105                     }
106                     assertNotNull(parts[3]);
107                     seenTags.add(parts[3]);
108 
109                     // Note the time fields are measured in milliseconds by default.
110                     switch (parts[3]) {
111                         case "vers":
112                             checkVersion(parts);
113                             break;
114                         case "uid":
115                             checkUid(parts);
116                             break;
117                         case "apk":
118                             checkApk(parts);
119                             break;
120                         case "pr":
121                             checkProcess(parts);
122                             break;
123                         case "sr":
124                             checkSensor(parts);
125                             break;
126                         case "vib":
127                             checkVibrator(parts);
128                             break;
129                         case "fg":
130                             checkForegroundActivity(parts);
131                             break;
132                         case "fgs":
133                             checkForegroundService(parts);
134                             break;
135                         case "st":
136                             checkStateTime(parts);
137                             break;
138                         case "wl":
139                             checkWakelock(parts);
140                             break;
141                         case "awl":
142                             checkAggregatedWakelock(parts);
143                             break;
144                         case "sy":
145                             checkSync(parts);
146                             break;
147                         case "jb":
148                             checkJob(parts);
149                             break;
150                         case "jbc":
151                             checkJobCompletion(parts);
152                             break;
153                         case "jbd":
154                             checkJobsDeferred(parts);
155                             break;
156                         case "kwl":
157                             checkKernelWakelock(parts);
158                             break;
159                         case "wr":
160                             checkWakeupReason(parts);
161                             break;
162                         case "nt":
163                             checkNetwork(parts);
164                             break;
165                         case "ua":
166                             checkUserActivity(parts);
167                             break;
168                         case "bt":
169                             checkBattery(parts);
170                             break;
171                         case "dc":
172                             checkBatteryDischarge(parts);
173                             break;
174                         case "lv":
175                             checkBatteryLevel(parts);
176                             break;
177                         case "wfl":
178                             checkWifi(parts);
179                             break;
180                         case "m":
181                             checkMisc(parts);
182                             break;
183                         case "gn":
184                             checkGlobalNetwork(parts);
185                             break;
186                         case "br":
187                             checkScreenBrightness(parts);
188                             break;
189                         case "sgt":
190                         case "sgc":
191                             checkSignalStrength(parts);
192                             break;
193                         case "sst":
194                             checkSignalScanningTime(parts);
195                             break;
196                         case "dct":
197                         case "dcc":
198                             checkDataConnection(parts);
199                             break;
200                         case "wst":
201                         case "wsc":
202                             checkWifiState(parts);
203                             break;
204                         case "wsst":
205                         case "wssc":
206                             checkWifiSupplState(parts);
207                             break;
208                         case "wsgt":
209                         case "wsgc":
210                             checkWifiSignalStrength(parts);
211                             break;
212                         case "bst":
213                         case "bsc":
214                             checkBluetoothState(parts);
215                             break;
216                         case "blem":
217                             checkBluetoothMisc(parts);
218                             break;
219                         case "pws":
220                             checkPowerUseSummary(parts);
221                             break;
222                         case "pwi":
223                             checkPowerUseItem(parts);
224                             break;
225                         case "dsd":
226                         case "csd":
227                             checkChargeDischargeStep(parts);
228                             break;
229                         case "dtr":
230                             checkDischargeTimeRemain(parts);
231                             break;
232                         case "ctr":
233                             checkChargeTimeRemain(parts);
234                             break;
235                         case "cpu":
236                             checkUidCpuUsage(parts);
237                             break;
238                         default:
239                             break;
240                     }
241                 } catch (AssertionError e) {
242                     CLog.e("Assert fail for line <" + line + ">");
243                     throw e;
244                 }
245             }
246         }
247 
248         // spot check a few tags
249         assertSeenTag(seenTags, "vers");
250         assertSeenTag(seenTags, "bt");
251         assertSeenTag(seenTags, "dc");
252         assertSeenTag(seenTags, "m");
253     }
254 
checkVersion(String[] parts)255     private void checkVersion(String[] parts) {
256         assertEquals(8, parts.length);
257         assertInteger(parts[4]); // checkinVersion
258         assertInteger(parts[5]); // parcelVersion
259         assertNotNull(parts[6]); // startPlatformVersion
260         assertNotNull(parts[7]); // endPlatformVersion
261     }
262 
checkUid(String[] parts)263     private void checkUid(String[] parts) {
264         assertEquals(6, parts.length);
265         assertInteger(parts[4]); // uid
266         assertNotNull(parts[5]); // pkgName
267     }
268 
checkApk(String[] parts)269     private void checkApk(String[] parts) {
270         assertEquals(10, parts.length);
271         long wakeup_count = assertInteger(parts[4]); // wakeups
272         assertNotNull(parts[5]); // apk
273         assertNotNull(parts[6]); // service
274         assertInteger(parts[7]); // startTime
275         assertInteger(parts[8]); // starts
276         assertInteger(parts[9]); // launches
277 
278         // Validation check.
279         assertTrue("wakeup count must be >= 0", wakeup_count >= 0);
280     }
281 
checkProcess(String[] parts)282     private void checkProcess(String[] parts) {
283         assertTrue(parts.length >= 9);
284         assertNotNull(parts[4]); // process
285         assertInteger(parts[5]); // userMillis
286         assertInteger(parts[6]); // systemMillis
287         assertInteger(parts[7]); // foregroundMillis
288         assertInteger(parts[8]); // starts
289     }
290 
checkSensor(String[] parts)291     private void checkSensor(String[] parts) {
292         assertEquals(10, parts.length);
293         assertInteger(parts[4]); // sensorNumber
294         assertInteger(parts[5]); // totalTime
295         assertInteger(parts[6]); // count
296         assertInteger(parts[7]); // backgroundCount
297         assertInteger(parts[8]); // actualTime
298         assertInteger(parts[9]); // backgroundActualTime
299     }
300 
checkVibrator(String[] parts)301     private void checkVibrator(String[] parts) {
302         assertEquals(6, parts.length);
303         assertInteger(parts[4]); // totalTime
304         assertInteger(parts[5]); // count
305     }
306 
checkForegroundActivity(String[] parts)307     private void checkForegroundActivity(String[] parts) {
308         assertEquals(6, parts.length);
309         assertInteger(parts[4]); // totalTime
310         assertInteger(parts[5]); // count
311     }
312 
checkForegroundService(String[] parts)313     private void checkForegroundService(String[] parts) {
314         assertEquals(6, parts.length);
315         assertInteger(parts[4]); // totalTime
316         assertInteger(parts[5]); // count
317     }
318 
checkStateTime(String[] parts)319     private void checkStateTime(String[] parts) {
320         assertEquals(11, parts.length);
321         assertInteger(parts[4]);  // top
322         assertInteger(parts[5]);  // foreground_service
323         assertInteger(parts[6]);  // foreground
324         assertInteger(parts[7]);  // background
325         assertInteger(parts[8]);  // top_sleeping
326         assertInteger(parts[9]);  // heavy_weight
327         assertInteger(parts[10]); // cached
328     }
329 
checkWakelock(String[] parts)330     private void checkWakelock(String[] parts) {
331         assertEquals(29, parts.length);
332         assertNotNull(parts[4]);      // wakelock
333 
334         assertInteger(parts[5]);      // full totalTime
335         assertEquals("f", parts[6]);  // full
336         long full_count = assertInteger(parts[7]);      // full count
337         assertInteger(parts[8]);      // current duration
338         assertInteger(parts[9]);      // max duration
339         assertInteger(parts[10]);     // total duration
340 
341         assertInteger(parts[11]);      // partial totalTime
342         assertEquals("p", parts[12]);  // partial
343         long partial_count = assertInteger(parts[13]);     // partial count
344         assertInteger(parts[14]);      // current duration
345         assertInteger(parts[15]);      // max duration
346         assertInteger(parts[16]);      // total duration
347 
348         assertInteger(parts[17]);      // background partial totalTime
349         assertEquals("bp", parts[18]); // background partial
350         long bg_partial_count = assertInteger(parts[19]);     // background partial count
351         assertInteger(parts[20]);      // current duration
352         assertInteger(parts[21]);      // max duration
353         assertInteger(parts[22]);      // total duration
354 
355         assertInteger(parts[23]);      // window totalTime
356         assertEquals("w", parts[24]);  // window
357         long window_count = assertInteger(parts[25]);     // window count
358         assertInteger(parts[26]);      // current duration
359         assertInteger(parts[27]);      // max duration
360         assertInteger(parts[28]);      // total duration
361 
362         // Validation checks.
363         assertTrue("full wakelock count must be >= 0", full_count >= 0);
364         assertTrue("partial wakelock count must be >= 0", partial_count >= 0);
365         assertTrue("background partial wakelock count must be >= 0", bg_partial_count >= 0);
366         assertTrue("window wakelock count must be >= 0", window_count >= 0);
367     }
368 
checkAggregatedWakelock(String[] parts)369     private void checkAggregatedWakelock(String[] parts) {
370         assertEquals(6, parts.length);
371         assertInteger(parts[4]); // total time
372         assertInteger(parts[5]); // background time
373     }
374 
checkSync(String[] parts)375     private void checkSync(String[] parts) {
376         assertEquals(9, parts.length);
377         assertNotNull(parts[4]); // sync
378         assertInteger(parts[5]); // totalTime
379         assertInteger(parts[6]); // count
380         assertInteger(parts[7]); // bgTime
381         assertInteger(parts[8]); // bgCount
382     }
383 
checkJob(String[] parts)384     private void checkJob(String[] parts) {
385         assertEquals(9, parts.length);
386         assertNotNull(parts[4]); // job
387         assertInteger(parts[5]); // totalTime
388         assertInteger(parts[6]); // count
389         assertInteger(parts[7]); // bgTime
390         assertInteger(parts[8]); // bgCount
391     }
392 
checkJobCompletion(String[] parts)393     private void checkJobCompletion(String[] parts) {
394         // This line contains a number for each job cancel reason.
395         // (See JobParameters.JOB_STOP_REASON_CODES), and future mainline updates may introudce
396         // more codes, so we have no upper bound for the number of columns.
397         assertThat(parts.length).isAtLeast(11);
398         assertNotNull(parts[4]); // job
399 
400         // Values for each of JOB_STOP_REASON_CODES.
401         for (int i = 5; i < parts.length; i++) {
402             assertInteger(parts[i]);
403         }
404     }
405 
checkJobsDeferred(String[] parts)406     private void checkJobsDeferred(String[] parts) {
407         assertEquals(12, parts.length);
408         assertInteger(parts[4]); // jobsDeferredEventCount
409         assertInteger(parts[5]); // jobsDeferredCount
410         assertInteger(parts[6]); // totalLatencyMillis
411         assertInteger(parts[7]); // count at latency < 1 hr
412         assertInteger(parts[8]); // count at latency 1-2 hrs
413         assertInteger(parts[9]); // count at latency 2-4 hrs
414         assertInteger(parts[10]); // count at latency 4-8 hrs
415         assertInteger(parts[11]); // count at latency 8+ hrs
416     }
417 
checkKernelWakelock(String[] parts)418     private void checkKernelWakelock(String[] parts) {
419         assertTrue(parts.length >= 7);
420 	assertNotNull(parts[4]); // Kernel wakelock
421 	assertInteger(parts[parts.length-2]); // totalTime
422         assertInteger(parts[parts.length-1]); // count
423     }
424 
checkWakeupReason(String[] parts)425     private void checkWakeupReason(String[] parts) {
426         assertTrue(parts.length >= 7);
427         for (int i = 4; i < parts.length-2; i++) {
428             assertNotNull(parts[i]); // part of wakeup
429         }
430         assertInteger(parts[parts.length-2]); // totalTime
431         assertInteger(parts[parts.length-1]); // count
432     }
433 
checkNetwork(String[] parts)434     private void checkNetwork(String[] parts) {
435         assertEquals(26, parts.length);
436         long mbRx = assertInteger(parts[4]);  // mobileBytesRx
437         long mbTx = assertInteger(parts[5]);  // mobileBytesTx
438         long wbRx = assertInteger(parts[6]);  // wifiBytesRx
439         long wbTx = assertInteger(parts[7]);  // wifiBytesTx
440         long mpRx = assertInteger(parts[8]);  // mobilePacketsRx
441         long mpTx = assertInteger(parts[9]);  // mobilePacketsTx
442         long wpRx = assertInteger(parts[10]); // wifiPacketsRx
443         long wpTx = assertInteger(parts[11]); // wifiPacketsTx
444         assertInteger(parts[12]); // mobileActiveTime (usec)
445         assertInteger(parts[13]); // mobileActiveCount
446         assertInteger(parts[14]); // btBytesRx
447         assertInteger(parts[15]); // btBytesTx
448         assertInteger(parts[16]); // mobileWakeup
449         assertInteger(parts[17]); // wifiWakeup
450         long mbBgRx = assertInteger(parts[18]);  // mobileBytesRx
451         long mbBgTx = assertInteger(parts[19]);  // mobileBytesTx
452         long wbBgRx = assertInteger(parts[20]);  // wifiBytesRx
453         long wbBgTx = assertInteger(parts[21]);  // wifiBytesTx
454         long mpBgRx = assertInteger(parts[22]);  // mobilePacketsRx
455         long mpBgTx = assertInteger(parts[23]);  // mobilePacketsTx
456         long wpBgRx = assertInteger(parts[24]); // wifiPacketsRx
457         long wpBgTx = assertInteger(parts[25]); // wifiPacketsTx
458 
459         // Assuming each packet contains some bytes, bytes >= packets >= 0.
460         assertTrue("mobileBytesRx must be >= mobilePacketsRx", mbRx >= mpRx);
461         assertTrue("mobilePacketsRx must be >= 0", mpRx >= 0);
462         assertTrue("mobileBytesTx must be >= mobilePacketsTx", mbTx >= mpTx);
463         assertTrue("mobilePacketsTx must be >= 0", mpTx >= 0);
464         assertTrue("wifiBytesRx must be >= wifiPacketsRx", wbRx >= wpRx);
465         assertTrue("wifiPacketsRx must be >= 0", wpRx >= 0);
466         assertTrue("wifiBytesTx must be >= wifiPacketsTx", wbTx >= wpTx);
467         assertTrue("wifiPacketsTx must be >= 0", wpTx >= 0);
468         // Totals should be greater than or equal to background data numbers
469         assertTrue("mobileBytesRx must be >= mobileBytesBgRx", mbRx >= mbBgRx);
470         assertTrue("mobilePacketsRx must be >= mobilePacketsBgRx", mpRx >= mpBgRx);
471         assertTrue("mobileBytesTx must be >= mobileBytesBgTx", mbTx >= mbBgTx);
472         assertTrue("mobilePacketsTx must be >= mobilePacketsBgTx", mpTx >= mpBgTx);
473         assertTrue("wifiBytesRx must be >= wifiBytesBgRx", wbRx >= wbBgRx);
474         assertTrue("wifiPacketsRx must be >= wifiPacketsBgRx", wpRx >= wpBgRx);
475         assertTrue("wifiBytesTx must be >= wifiBytesBgTx", wbTx >= wbBgTx);
476         assertTrue("wifiPacketsTx must be >= wifiPacketsBgTx", wpTx >= wpBgTx);
477     }
478 
checkUserActivity(String[] parts)479     private void checkUserActivity(String[] parts) {
480         assertEquals(11, parts.length);
481         assertInteger(parts[4]); // other
482         assertInteger(parts[5]); // button
483         assertInteger(parts[6]); // touch
484         assertInteger(parts[7]); // accessibility
485         assertInteger(parts[8]); // attention
486         assertInteger(parts[9]); // faceDown
487         assertInteger(parts[10]); // deviceState
488 
489     }
490 
checkBattery(String[] parts)491     private void checkBattery(String[] parts) {
492         assertEquals(16, parts.length);
493         if (!parts[4].equals("N/A")) {
494             assertInteger(parts[4]);  // startCount
495         }
496         long bReal = assertInteger(parts[5]);  // batteryRealtime
497         long bUp = assertInteger(parts[6]);  // batteryUptime
498         long tReal = assertInteger(parts[7]);  // totalRealtime
499         long tUp = assertInteger(parts[8]);  // totalUptime
500         assertInteger(parts[9]);  // startClockTime
501         long bOffReal = assertInteger(parts[10]); // batteryScreenOffRealtime
502         long bOffUp = assertInteger(parts[11]); // batteryScreenOffUptime
503         long bEstCap = assertInteger(parts[12]); // batteryEstimatedCapacity
504         assertInteger(parts[13]); // minLearnedBatteryCapacity
505         assertInteger(parts[14]); // maxLearnedBatteryCapacity
506         long bDoze = assertInteger(parts[15]); // screenDozeTime
507 
508         // The device cannot be up more than there are real-world seconds.
509         assertTrue("batteryRealtime must be >= batteryUptime", bReal >= bUp);
510         assertTrue("totalRealtime must be >= totalUptime", tReal >= tUp);
511         assertTrue("batteryScreenOffRealtime must be >= batteryScreenOffUptime",
512                 bOffReal >= bOffUp);
513 
514         // total >= battery >= battery screen-off >= 0
515         assertTrue("totalRealtime must be >= batteryRealtime", tReal >= bReal);
516         assertTrue("batteryRealtime must be >= batteryScreenOffRealtime", bReal >= bOffReal);
517         assertTrue("batteryScreenOffRealtime must be >= 0", bOffReal >= 0);
518         assertTrue("totalUptime must be >= batteryUptime", tUp >= bUp);
519         assertTrue("batteryUptime must be >= batteryScreenOffUptime", bUp >= bOffUp);
520         assertTrue("batteryScreenOffUptime must be >= 0", bOffUp >= 0);
521         assertTrue("batteryEstimatedCapacity must be >= 0", bEstCap >= 0);
522         assertTrue("screenDozeTime must be >= 0", bDoze >= 0);
523         assertTrue("screenDozeTime must be <= batteryScreenOffRealtime", bDoze <= bOffReal);
524     }
525 
checkBatteryDischarge(String[] parts)526     private void checkBatteryDischarge(String[] parts) {
527         assertEquals(14, parts.length);
528         assertInteger(parts[4]); // low
529         assertInteger(parts[5]); // high
530         assertInteger(parts[6]); // screenOn
531         assertInteger(parts[7]); // screenOff
532         assertInteger(parts[8]); // dischargeMah
533         assertInteger(parts[9]); // dischargeScreenOffMah
534         assertInteger(parts[10]); // dischargeDozeCount
535         assertInteger(parts[11]); // dischargeDozeMah
536         assertInteger(parts[12]); // dischargeLightDozeMah
537         assertInteger(parts[13]); // dischargeDeepDozeMah
538     }
539 
checkBatteryLevel(String[] parts)540     private void checkBatteryLevel(String[] parts) {
541         assertEquals(6, parts.length);
542         assertInteger(parts[4]); // startLevel
543         assertInteger(parts[5]); // currentLevel
544     }
545 
checkWifi(String[] parts)546     private void checkWifi(String[] parts) {
547         assertEquals(14, parts.length);
548         assertInteger(parts[4]); // fullWifiLockOnTime (usec)
549         assertInteger(parts[5]); // wifiScanTime (usec)
550         assertInteger(parts[6]); // uidWifiRunningTime (usec)
551         assertInteger(parts[7]); // wifiScanCount
552         // Fields for parts[8 and 9 and 10] are deprecated.
553         assertInteger(parts[11]); // wifiScanCountBg
554         assertInteger(parts[12]); // wifiScanActualTimeMs (msec)
555         assertInteger(parts[13]); // wifiScanActualTimeMsBg (msec)
556     }
557 
checkMisc(String[] parts)558     private void checkMisc(String[] parts) {
559         assertTrue(parts.length >= 19);
560         assertInteger(parts[4]);      // screenOnTime
561         assertInteger(parts[5]);      // phoneOnTime
562         assertInteger(parts[6]);      // fullWakeLockTimeTotal
563         assertInteger(parts[7]);      // partialWakeLockTimeTotal
564         assertInteger(parts[8]);      // mobileRadioActiveTime
565         assertInteger(parts[9]);      // mobileRadioActiveAdjustedTime
566         assertInteger(parts[10]);     // interactiveTime
567         assertInteger(parts[11]);     // lowPowerModeEnabledTime
568         assertInteger(parts[12]);     // connChanges
569         assertInteger(parts[13]);     // deviceIdleModeEnabledTime
570         assertInteger(parts[14]);     // deviceIdleModeEnabledCount
571         assertInteger(parts[15]);     // deviceIdlingTime
572         assertInteger(parts[16]);     // deviceIdlingCount
573         assertInteger(parts[17]);     // mobileRadioActiveCount
574         assertInteger(parts[18]);     // mobileRadioActiveUnknownTime
575     }
576 
checkGlobalNetwork(String[] parts)577     private void checkGlobalNetwork(String[] parts) {
578         assertEquals(14, parts.length);
579         assertInteger(parts[4]);  // mobileRxTotalBytes
580         assertInteger(parts[5]);  // mobileTxTotalBytes
581         assertInteger(parts[6]);  // wifiRxTotalBytes
582         assertInteger(parts[7]);  // wifiTxTotalBytes
583         assertInteger(parts[8]);  // mobileRxTotalPackets
584         assertInteger(parts[9]);  // mobileTxTotalPackets
585         assertInteger(parts[10]); // wifiRxTotalPackets
586         assertInteger(parts[11]); // wifiTxTotalPackets
587         assertInteger(parts[12]); // btRxTotalBytes
588         assertInteger(parts[13]); // btTxTotalBytes
589     }
590 
checkScreenBrightness(String[] parts)591     private void checkScreenBrightness(String[] parts) {
592         assertEquals(9, parts.length);
593         assertInteger(parts[4]); // dark
594         assertInteger(parts[5]); // dim
595         assertInteger(parts[6]); // medium
596         assertInteger(parts[7]); // light
597         assertInteger(parts[8]); // bright
598     }
599 
checkSignalStrength(String[] parts)600     private void checkSignalStrength(String[] parts) {
601         assertTrue(parts.length >= 9);
602         assertInteger(parts[4]); // none
603         assertInteger(parts[5]); // poor
604         assertInteger(parts[6]); // moderate
605         assertInteger(parts[7]); // good
606         assertInteger(parts[8]); // great
607     }
608 
checkSignalScanningTime(String[] parts)609     private void checkSignalScanningTime(String[] parts) {
610         assertEquals(5, parts.length);
611         assertInteger(parts[4]); // signalScanningTime
612     }
613 
checkDataConnection(String[] parts)614     private void checkDataConnection(String[] parts) {
615         assertEquals(27, parts.length);
616         assertInteger(parts[4]);  // none
617         assertInteger(parts[5]);  // gprs
618         assertInteger(parts[6]);  // edge
619         assertInteger(parts[7]);  // umts
620         assertInteger(parts[8]);  // cdma
621         assertInteger(parts[9]);  // evdo_0
622         assertInteger(parts[10]); // evdo_A
623         assertInteger(parts[11]); // 1xrtt
624         assertInteger(parts[12]); // hsdpa
625         assertInteger(parts[13]); // hsupa
626         assertInteger(parts[14]); // hspa
627         assertInteger(parts[15]); // iden
628         assertInteger(parts[16]); // evdo_b
629         assertInteger(parts[17]); // lte
630         assertInteger(parts[18]); // ehrpd
631         assertInteger(parts[19]); // hspap
632         assertInteger(parts[20]); // gsm
633         assertInteger(parts[21]); // td_scdma
634         assertInteger(parts[22]); // iwlan
635         assertInteger(parts[23]); // lte_ca
636         assertInteger(parts[24]); // nr
637         assertInteger(parts[25]); // emngcy
638         assertInteger(parts[26]); // other
639     }
640 
checkWifiState(String[] parts)641     private void checkWifiState(String[] parts) {
642         assertEquals(12, parts.length);
643         assertInteger(parts[4]);  // off
644         assertInteger(parts[5]);  // scanning
645         assertInteger(parts[6]);  // no_net
646         assertInteger(parts[7]);  // disconn
647         assertInteger(parts[8]);  // sta
648         assertInteger(parts[9]);  // p2p
649         assertInteger(parts[10]); // sta_p2p
650         assertInteger(parts[11]); // soft_ap
651     }
652 
checkWifiSupplState(String[] parts)653     private void checkWifiSupplState(String[] parts) {
654         assertEquals(17, parts.length);
655         assertInteger(parts[4]);  // inv
656         assertInteger(parts[5]);  // dsc
657         assertInteger(parts[6]);  // dis
658         assertInteger(parts[7]);  // inact
659         assertInteger(parts[8]);  // scan
660         assertInteger(parts[9]);  // auth
661         assertInteger(parts[10]); // ascing
662         assertInteger(parts[11]); // asced
663         assertInteger(parts[12]); // 4-way
664         assertInteger(parts[13]); // group
665         assertInteger(parts[14]); // compl
666         assertInteger(parts[15]); // dorm
667         assertInteger(parts[16]); // uninit
668     }
669 
checkWifiSignalStrength(String[] parts)670     private void checkWifiSignalStrength(String[] parts) {
671         assertEquals(9, parts.length);
672         assertInteger(parts[4]); // none
673         assertInteger(parts[5]); // poor
674         assertInteger(parts[6]); // moderate
675         assertInteger(parts[7]); // good
676         assertInteger(parts[8]); // great
677     }
678 
checkBluetoothState(String[] parts)679     private void checkBluetoothState(String[] parts) {
680         assertEquals(8, parts.length);
681         assertInteger(parts[4]); // inactive
682         assertInteger(parts[5]); // low
683         assertInteger(parts[6]); // med
684         assertInteger(parts[7]); // high
685     }
686 
checkPowerUseSummary(String[] parts)687     private void checkPowerUseSummary(String[] parts) {
688         assertEquals(8, parts.length);
689         assertDouble(parts[4]); // batteryCapacity
690         assertDouble(parts[5]); // computedPower
691         assertDouble(parts[6]); // minDrainedPower
692         assertDouble(parts[7]); // maxDrainedPower
693     }
694 
checkPowerUseItem(String[] parts)695     private void checkPowerUseItem(String[] parts) {
696         assertEquals(9, parts.length);
697         assertNotNull(parts[4]); // label
698         final double totalPowerMah = assertDouble(parts[5]);  // totalPowerMah
699         final long shouldHide = assertInteger(parts[6]);  // shouldHide (0 or 1)
700         final double screenPowerMah = assertDouble(parts[7]);  // screenPowerMah
701         final double proportionalSmearMah = assertDouble(parts[8]);  // proportionalSmearMah
702 
703         assertTrue("powerUseItem totalPowerMah must be >= 0", totalPowerMah >= 0);
704         assertTrue("powerUseItem screenPowerMah must be >= 0", screenPowerMah >= 0);
705         assertTrue("powerUseItem proportionalSmearMah must be >= 0", proportionalSmearMah >= 0);
706         assertTrue("powerUseItem shouldHide must be 0 or 1", shouldHide == 0 || shouldHide == 1);
707 
708         // Largest current Android battery is ~5K. 100K shouldn't get made for a while.
709         assertTrue("powerUseItem totalPowerMah is expected to be <= 100000", totalPowerMah <= 100000);
710     }
711 
checkChargeDischargeStep(String[] parts)712     private void checkChargeDischargeStep(String[] parts) {
713         assertEquals(9, parts.length);
714         assertInteger(parts[4]); // duration
715         if (!parts[5].equals("?")) {
716             assertInteger(parts[5]); // level
717         }
718         assertNotNull(parts[6]); // screen
719         assertNotNull(parts[7]); // power-save
720         assertNotNull(parts[8]); // device-idle
721     }
722 
checkDischargeTimeRemain(String[] parts)723     private void checkDischargeTimeRemain(String[] parts) {
724         assertEquals(5, parts.length);
725         assertInteger(parts[4]); // batteryTimeRemaining
726     }
727 
checkChargeTimeRemain(String[] parts)728     private void checkChargeTimeRemain(String[] parts) {
729         assertEquals(5, parts.length);
730         assertInteger(parts[4]); // chargeTimeRemaining
731     }
732 
checkUidCpuUsage(String[] parts)733     private void checkUidCpuUsage(String[] parts) {
734         assertTrue(parts.length >= 6);
735         assertInteger(parts[4]); // user time
736         assertInteger(parts[5]); // system time
737     }
738 
checkBluetoothMisc(String[] parts)739     private void checkBluetoothMisc(String[] parts) {
740         assertEquals(15, parts.length);
741         assertInteger(parts[4]); // totalTime
742         assertInteger(parts[5]); // count
743         assertInteger(parts[6]); // countBg
744         assertInteger(parts[7]); // actualTime
745         assertInteger(parts[8]); // actualTimeBg
746         assertInteger(parts[9]); // resultsCount
747         assertInteger(parts[10]); // resultsCountBg
748         assertInteger(parts[11]); // unoptimizedScanTotalTime
749         assertInteger(parts[12]); // unoptimizedScanTotalTimeBg
750         assertInteger(parts[13]); // unoptimizedScanMaxTime
751         assertInteger(parts[14]); // unoptimizedScanMaxTimeBg
752     }
753 }
754