| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.dumpsys.cts; |
| |
| import com.android.compatibility.common.tradefed.build.CompatibilityBuildHelper; |
| import com.android.tradefed.log.LogUtil.CLog; |
| |
| import java.io.BufferedReader; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.StringReader; |
| import java.util.HashSet; |
| import java.util.Set; |
| |
| /** |
| * Test to check the format of the dumps of the batterystats test. |
| */ |
| public class BatteryStatsDumpsysTest extends BaseDumpsysTest { |
| private static final String TEST_APK = "CtsFramestatsTestApp.apk"; |
| private static final String TEST_PKG = "com.android.cts.framestatstestapp"; |
| |
| /** |
| * Tests the output of "dumpsys batterystats --checkin". |
| * |
| * @throws Exception |
| */ |
| public void testBatterystatsOutput() throws Exception { |
| String batterystats = mDevice.executeShellCommand("dumpsys batterystats --checkin"); |
| assertNotNull(batterystats); |
| assertTrue(batterystats.length() > 0); |
| |
| Set<String> seenTags = new HashSet<>(); |
| |
| try (BufferedReader reader = new BufferedReader( |
| new StringReader(batterystats))) { |
| |
| String line; |
| while ((line = reader.readLine()) != null) { |
| if (line.isEmpty()) { |
| continue; |
| } |
| |
| |
| try { |
| // With a default limit of 0, empty strings at the end are discarded. |
| // We still consider the empty string as a valid value in some cases. |
| // Using any negative number for the limit will preserve a trailing empty string. |
| // @see String#split(String, int) |
| String[] parts = line.split(",", -1); |
| assertInteger(parts[0]); // old version |
| assertInteger(parts[1]); // UID |
| switch (parts[2]) { // aggregation type |
| case "i": |
| case "l": |
| case "c": |
| case "u": |
| break; |
| default: |
| fail("malformed stat: " + parts[2]); |
| } |
| assertNotNull(parts[3]); |
| seenTags.add(parts[3]); |
| |
| // Note the time fields are measured in milliseconds by default. |
| switch (parts[3]) { |
| case "vers": |
| checkVersion(parts); |
| break; |
| case "uid": |
| checkUid(parts); |
| break; |
| case "apk": |
| checkApk(parts); |
| break; |
| case "pr": |
| checkProcess(parts); |
| break; |
| case "sr": |
| checkSensor(parts); |
| break; |
| case "vib": |
| checkVibrator(parts); |
| break; |
| case "fg": |
| checkForegroundActivity(parts); |
| break; |
| case "fgs": |
| checkForegroundService(parts); |
| break; |
| case "st": |
| checkStateTime(parts); |
| break; |
| case "wl": |
| checkWakelock(parts); |
| break; |
| case "awl": |
| checkAggregatedWakelock(parts); |
| break; |
| case "sy": |
| checkSync(parts); |
| break; |
| case "jb": |
| checkJob(parts); |
| break; |
| case "jbc": |
| checkJobCompletion(parts); |
| break; |
| case "jbd": |
| checkJobsDeferred(parts); |
| break; |
| case "kwl": |
| checkKernelWakelock(parts); |
| break; |
| case "wr": |
| checkWakeupReason(parts); |
| break; |
| case "nt": |
| checkNetwork(parts); |
| break; |
| case "ua": |
| checkUserActivity(parts); |
| break; |
| case "bt": |
| checkBattery(parts); |
| break; |
| case "dc": |
| checkBatteryDischarge(parts); |
| break; |
| case "lv": |
| checkBatteryLevel(parts); |
| break; |
| case "wfl": |
| checkWifi(parts); |
| break; |
| case "m": |
| checkMisc(parts); |
| break; |
| case "gn": |
| checkGlobalNetwork(parts); |
| break; |
| case "br": |
| checkScreenBrightness(parts); |
| break; |
| case "sgt": |
| case "sgc": |
| checkSignalStrength(parts); |
| break; |
| case "sst": |
| checkSignalScanningTime(parts); |
| break; |
| case "dct": |
| case "dcc": |
| checkDataConnection(parts); |
| break; |
| case "wst": |
| case "wsc": |
| checkWifiState(parts); |
| break; |
| case "wsst": |
| case "wssc": |
| checkWifiSupplState(parts); |
| break; |
| case "wsgt": |
| case "wsgc": |
| checkWifiSignalStrength(parts); |
| break; |
| case "bst": |
| case "bsc": |
| checkBluetoothState(parts); |
| break; |
| case "blem": |
| checkBluetoothMisc(parts); |
| break; |
| case "pws": |
| checkPowerUseSummary(parts); |
| break; |
| case "pwi": |
| checkPowerUseItem(parts); |
| break; |
| case "dsd": |
| case "csd": |
| checkChargeDischargeStep(parts); |
| break; |
| case "dtr": |
| checkDischargeTimeRemain(parts); |
| break; |
| case "ctr": |
| checkChargeTimeRemain(parts); |
| break; |
| case "cpu": |
| checkUidCpuUsage(parts); |
| break; |
| default: |
| break; |
| } |
| } catch (AssertionError e) { |
| CLog.e("Assert fail for line <" + line + ">"); |
| throw e; |
| } |
| } |
| } |
| |
| // spot check a few tags |
| assertSeenTag(seenTags, "vers"); |
| assertSeenTag(seenTags, "bt"); |
| assertSeenTag(seenTags, "dc"); |
| assertSeenTag(seenTags, "m"); |
| } |
| |
| private void checkVersion(String[] parts) { |
| assertEquals(8, parts.length); |
| assertInteger(parts[4]); // checkinVersion |
| assertInteger(parts[5]); // parcelVersion |
| assertNotNull(parts[6]); // startPlatformVersion |
| assertNotNull(parts[7]); // endPlatformVersion |
| } |
| |
| private void checkUid(String[] parts) { |
| assertEquals(6, parts.length); |
| assertInteger(parts[4]); // uid |
| assertNotNull(parts[5]); // pkgName |
| } |
| |
| private void checkApk(String[] parts) { |
| assertEquals(10, parts.length); |
| long wakeup_count = assertInteger(parts[4]); // wakeups |
| assertNotNull(parts[5]); // apk |
| assertNotNull(parts[6]); // service |
| assertInteger(parts[7]); // startTime |
| assertInteger(parts[8]); // starts |
| assertInteger(parts[9]); // launches |
| |
| // Sanity check. |
| assertTrue("wakeup count must be >= 0", wakeup_count >= 0); |
| } |
| |
| private void checkProcess(String[] parts) { |
| assertTrue(parts.length >= 9); |
| assertNotNull(parts[4]); // process |
| assertInteger(parts[5]); // userMillis |
| assertInteger(parts[6]); // systemMillis |
| assertInteger(parts[7]); // foregroundMillis |
| assertInteger(parts[8]); // starts |
| } |
| |
| private void checkSensor(String[] parts) { |
| assertEquals(10, parts.length); |
| assertInteger(parts[4]); // sensorNumber |
| assertInteger(parts[5]); // totalTime |
| assertInteger(parts[6]); // count |
| assertInteger(parts[7]); // backgroundCount |
| assertInteger(parts[8]); // actualTime |
| assertInteger(parts[9]); // backgroundActualTime |
| } |
| |
| private void checkVibrator(String[] parts) { |
| assertEquals(6, parts.length); |
| assertInteger(parts[4]); // totalTime |
| assertInteger(parts[5]); // count |
| } |
| |
| private void checkForegroundActivity(String[] parts) { |
| assertEquals(6, parts.length); |
| assertInteger(parts[4]); // totalTime |
| assertInteger(parts[5]); // count |
| } |
| |
| private void checkForegroundService(String[] parts) { |
| assertEquals(6, parts.length); |
| assertInteger(parts[4]); // totalTime |
| assertInteger(parts[5]); // count |
| } |
| |
| private void checkStateTime(String[] parts) { |
| assertEquals(11, parts.length); |
| assertInteger(parts[4]); // top |
| assertInteger(parts[5]); // foreground_service |
| assertInteger(parts[6]); // foreground |
| assertInteger(parts[7]); // background |
| assertInteger(parts[8]); // top_sleeping |
| assertInteger(parts[9]); // heavy_weight |
| assertInteger(parts[10]); // cached |
| } |
| |
| private void checkWakelock(String[] parts) { |
| assertEquals(29, parts.length); |
| assertNotNull(parts[4]); // wakelock |
| |
| assertInteger(parts[5]); // full totalTime |
| assertEquals("f", parts[6]); // full |
| long full_count = assertInteger(parts[7]); // full count |
| assertInteger(parts[8]); // current duration |
| assertInteger(parts[9]); // max duration |
| assertInteger(parts[10]); // total duration |
| |
| assertInteger(parts[11]); // partial totalTime |
| assertEquals("p", parts[12]); // partial |
| long partial_count = assertInteger(parts[13]); // partial count |
| assertInteger(parts[14]); // current duration |
| assertInteger(parts[15]); // max duration |
| assertInteger(parts[16]); // total duration |
| |
| assertInteger(parts[17]); // background partial totalTime |
| assertEquals("bp", parts[18]); // background partial |
| long bg_partial_count = assertInteger(parts[19]); // background partial count |
| assertInteger(parts[20]); // current duration |
| assertInteger(parts[21]); // max duration |
| assertInteger(parts[22]); // total duration |
| |
| assertInteger(parts[23]); // window totalTime |
| assertEquals("w", parts[24]); // window |
| long window_count = assertInteger(parts[25]); // window count |
| assertInteger(parts[26]); // current duration |
| assertInteger(parts[27]); // max duration |
| assertInteger(parts[28]); // total duration |
| |
| // Sanity checks. |
| assertTrue("full wakelock count must be >= 0", full_count >= 0); |
| assertTrue("partial wakelock count must be >= 0", partial_count >= 0); |
| assertTrue("background partial wakelock count must be >= 0", bg_partial_count >= 0); |
| assertTrue("window wakelock count must be >= 0", window_count >= 0); |
| } |
| |
| private void checkAggregatedWakelock(String[] parts) { |
| assertEquals(6, parts.length); |
| assertInteger(parts[4]); // total time |
| assertInteger(parts[5]); // background time |
| } |
| |
| private void checkSync(String[] parts) { |
| assertEquals(9, parts.length); |
| assertNotNull(parts[4]); // sync |
| assertInteger(parts[5]); // totalTime |
| assertInteger(parts[6]); // count |
| assertInteger(parts[7]); // bgTime |
| assertInteger(parts[8]); // bgCount |
| } |
| |
| private void checkJob(String[] parts) { |
| assertEquals(9, parts.length); |
| assertNotNull(parts[4]); // job |
| assertInteger(parts[5]); // totalTime |
| assertInteger(parts[6]); // count |
| assertInteger(parts[7]); // bgTime |
| assertInteger(parts[8]); // bgCount |
| } |
| |
| private void checkJobCompletion(String[] parts) { |
| assertEquals(10, parts.length); |
| assertNotNull(parts[4]); // job |
| assertInteger(parts[5]); // reason_canceled |
| assertInteger(parts[6]); // reason_constraints_not_satisfied |
| assertInteger(parts[7]); // reason_preempt |
| assertInteger(parts[8]); // reason_timeout |
| assertInteger(parts[9]); // reason_device_idle |
| } |
| |
| private void checkJobsDeferred(String[] parts) { |
| assertEquals(12, parts.length); |
| assertInteger(parts[4]); // jobsDeferredEventCount |
| assertInteger(parts[5]); // jobsDeferredCount |
| assertInteger(parts[6]); // totalLatencyMillis |
| assertInteger(parts[7]); // count at latency < 1 hr |
| assertInteger(parts[8]); // count at latency 1-2 hrs |
| assertInteger(parts[9]); // count at latency 2-4 hrs |
| assertInteger(parts[10]); // count at latency 4-8 hrs |
| assertInteger(parts[11]); // count at latency 8+ hrs |
| } |
| |
| private void checkKernelWakelock(String[] parts) { |
| assertTrue(parts.length >= 7); |
| assertNotNull(parts[4]); // Kernel wakelock |
| assertInteger(parts[parts.length-2]); // totalTime |
| assertInteger(parts[parts.length-1]); // count |
| } |
| |
| private void checkWakeupReason(String[] parts) { |
| assertTrue(parts.length >= 7); |
| for (int i = 4; i < parts.length-2; i++) { |
| assertNotNull(parts[i]); // part of wakeup |
| } |
| assertInteger(parts[parts.length-2]); // totalTime |
| assertInteger(parts[parts.length-1]); // count |
| } |
| |
| private void checkNetwork(String[] parts) { |
| assertEquals(26, parts.length); |
| long mbRx = assertInteger(parts[4]); // mobileBytesRx |
| long mbTx = assertInteger(parts[5]); // mobileBytesTx |
| long wbRx = assertInteger(parts[6]); // wifiBytesRx |
| long wbTx = assertInteger(parts[7]); // wifiBytesTx |
| long mpRx = assertInteger(parts[8]); // mobilePacketsRx |
| long mpTx = assertInteger(parts[9]); // mobilePacketsTx |
| long wpRx = assertInteger(parts[10]); // wifiPacketsRx |
| long wpTx = assertInteger(parts[11]); // wifiPacketsTx |
| assertInteger(parts[12]); // mobileActiveTime (usec) |
| assertInteger(parts[13]); // mobileActiveCount |
| assertInteger(parts[14]); // btBytesRx |
| assertInteger(parts[15]); // btBytesTx |
| assertInteger(parts[16]); // mobileWakeup |
| assertInteger(parts[17]); // wifiWakeup |
| long mbBgRx = assertInteger(parts[18]); // mobileBytesRx |
| long mbBgTx = assertInteger(parts[19]); // mobileBytesTx |
| long wbBgRx = assertInteger(parts[20]); // wifiBytesRx |
| long wbBgTx = assertInteger(parts[21]); // wifiBytesTx |
| long mpBgRx = assertInteger(parts[22]); // mobilePacketsRx |
| long mpBgTx = assertInteger(parts[23]); // mobilePacketsTx |
| long wpBgRx = assertInteger(parts[24]); // wifiPacketsRx |
| long wpBgTx = assertInteger(parts[25]); // wifiPacketsTx |
| |
| // Assuming each packet contains some bytes, bytes >= packets >= 0. |
| assertTrue("mobileBytesRx must be >= mobilePacketsRx", mbRx >= mpRx); |
| assertTrue("mobilePacketsRx must be >= 0", mpRx >= 0); |
| assertTrue("mobileBytesTx must be >= mobilePacketsTx", mbTx >= mpTx); |
| assertTrue("mobilePacketsTx must be >= 0", mpTx >= 0); |
| assertTrue("wifiBytesRx must be >= wifiPacketsRx", wbRx >= wpRx); |
| assertTrue("wifiPacketsRx must be >= 0", wpRx >= 0); |
| assertTrue("wifiBytesTx must be >= wifiPacketsTx", wbTx >= wpTx); |
| assertTrue("wifiPacketsTx must be >= 0", wpTx >= 0); |
| // Totals should be greater than or equal to background data numbers |
| assertTrue("mobileBytesRx must be >= mobileBytesBgRx", mbRx >= mbBgRx); |
| assertTrue("mobilePacketsRx must be >= mobilePacketsBgRx", mpRx >= mpBgRx); |
| assertTrue("mobileBytesTx must be >= mobileBytesBgTx", mbTx >= mbBgTx); |
| assertTrue("mobilePacketsTx must be >= mobilePacketsBgTx", mpTx >= mpBgTx); |
| assertTrue("wifiBytesRx must be >= wifiBytesBgRx", wbRx >= wbBgRx); |
| assertTrue("wifiPacketsRx must be >= wifiPacketsBgRx", wpRx >= wpBgRx); |
| assertTrue("wifiBytesTx must be >= wifiBytesBgTx", wbTx >= wbBgTx); |
| assertTrue("wifiPacketsTx must be >= wifiPacketsBgTx", wpTx >= wpBgTx); |
| } |
| |
| private void checkUserActivity(String[] parts) { |
| assertEquals(9, parts.length); |
| assertInteger(parts[4]); // other |
| assertInteger(parts[5]); // button |
| assertInteger(parts[6]); // touch |
| assertInteger(parts[7]); // accessibility |
| assertInteger(parts[8]); // attention |
| } |
| |
| private void checkBattery(String[] parts) { |
| assertEquals(16, parts.length); |
| if (!parts[4].equals("N/A")) { |
| assertInteger(parts[4]); // startCount |
| } |
| long bReal = assertInteger(parts[5]); // batteryRealtime |
| long bUp = assertInteger(parts[6]); // batteryUptime |
| long tReal = assertInteger(parts[7]); // totalRealtime |
| long tUp = assertInteger(parts[8]); // totalUptime |
| assertInteger(parts[9]); // startClockTime |
| long bOffReal = assertInteger(parts[10]); // batteryScreenOffRealtime |
| long bOffUp = assertInteger(parts[11]); // batteryScreenOffUptime |
| long bEstCap = assertInteger(parts[12]); // batteryEstimatedCapacity |
| assertInteger(parts[13]); // minLearnedBatteryCapacity |
| assertInteger(parts[14]); // maxLearnedBatteryCapacity |
| long bDoze = assertInteger(parts[15]); // screenDozeTime |
| |
| // The device cannot be up more than there are real-world seconds. |
| assertTrue("batteryRealtime must be >= batteryUptime", bReal >= bUp); |
| assertTrue("totalRealtime must be >= totalUptime", tReal >= tUp); |
| assertTrue("batteryScreenOffRealtime must be >= batteryScreenOffUptime", |
| bOffReal >= bOffUp); |
| |
| // total >= battery >= battery screen-off >= 0 |
| assertTrue("totalRealtime must be >= batteryRealtime", tReal >= bReal); |
| assertTrue("batteryRealtime must be >= batteryScreenOffRealtime", bReal >= bOffReal); |
| assertTrue("batteryScreenOffRealtime must be >= 0", bOffReal >= 0); |
| assertTrue("totalUptime must be >= batteryUptime", tUp >= bUp); |
| assertTrue("batteryUptime must be >= batteryScreenOffUptime", bUp >= bOffUp); |
| assertTrue("batteryScreenOffUptime must be >= 0", bOffUp >= 0); |
| assertTrue("batteryEstimatedCapacity must be >= 0", bEstCap >= 0); |
| assertTrue("screenDozeTime must be >= 0", bDoze >= 0); |
| assertTrue("screenDozeTime must be <= batteryScreenOffRealtime", bDoze <= bOffReal); |
| } |
| |
| private void checkBatteryDischarge(String[] parts) { |
| assertEquals(14, parts.length); |
| assertInteger(parts[4]); // low |
| assertInteger(parts[5]); // high |
| assertInteger(parts[6]); // screenOn |
| assertInteger(parts[7]); // screenOff |
| assertInteger(parts[8]); // dischargeMah |
| assertInteger(parts[9]); // dischargeScreenOffMah |
| assertInteger(parts[10]); // dischargeDozeCount |
| assertInteger(parts[11]); // dischargeDozeMah |
| assertInteger(parts[12]); // dischargeLightDozeMah |
| assertInteger(parts[13]); // dischargeDeepDozeMah |
| } |
| |
| private void checkBatteryLevel(String[] parts) { |
| assertEquals(6, parts.length); |
| assertInteger(parts[4]); // startLevel |
| assertInteger(parts[5]); // currentLevel |
| } |
| |
| private void checkWifi(String[] parts) { |
| assertEquals(14, parts.length); |
| assertInteger(parts[4]); // fullWifiLockOnTime (usec) |
| assertInteger(parts[5]); // wifiScanTime (usec) |
| assertInteger(parts[6]); // uidWifiRunningTime (usec) |
| assertInteger(parts[7]); // wifiScanCount |
| // Fields for parts[8 and 9 and 10] are deprecated. |
| assertInteger(parts[11]); // wifiScanCountBg |
| assertInteger(parts[12]); // wifiScanActualTimeMs (msec) |
| assertInteger(parts[13]); // wifiScanActualTimeMsBg (msec) |
| } |
| |
| private void checkMisc(String[] parts) { |
| assertTrue(parts.length >= 19); |
| assertInteger(parts[4]); // screenOnTime |
| assertInteger(parts[5]); // phoneOnTime |
| assertInteger(parts[6]); // fullWakeLockTimeTotal |
| assertInteger(parts[7]); // partialWakeLockTimeTotal |
| assertInteger(parts[8]); // mobileRadioActiveTime |
| assertInteger(parts[9]); // mobileRadioActiveAdjustedTime |
| assertInteger(parts[10]); // interactiveTime |
| assertInteger(parts[11]); // lowPowerModeEnabledTime |
| assertInteger(parts[12]); // connChanges |
| assertInteger(parts[13]); // deviceIdleModeEnabledTime |
| assertInteger(parts[14]); // deviceIdleModeEnabledCount |
| assertInteger(parts[15]); // deviceIdlingTime |
| assertInteger(parts[16]); // deviceIdlingCount |
| assertInteger(parts[17]); // mobileRadioActiveCount |
| assertInteger(parts[18]); // mobileRadioActiveUnknownTime |
| } |
| |
| private void checkGlobalNetwork(String[] parts) { |
| assertEquals(14, parts.length); |
| assertInteger(parts[4]); // mobileRxTotalBytes |
| assertInteger(parts[5]); // mobileTxTotalBytes |
| assertInteger(parts[6]); // wifiRxTotalBytes |
| assertInteger(parts[7]); // wifiTxTotalBytes |
| assertInteger(parts[8]); // mobileRxTotalPackets |
| assertInteger(parts[9]); // mobileTxTotalPackets |
| assertInteger(parts[10]); // wifiRxTotalPackets |
| assertInteger(parts[11]); // wifiTxTotalPackets |
| assertInteger(parts[12]); // btRxTotalBytes |
| assertInteger(parts[13]); // btTxTotalBytes |
| } |
| |
| private void checkScreenBrightness(String[] parts) { |
| assertEquals(9, parts.length); |
| assertInteger(parts[4]); // dark |
| assertInteger(parts[5]); // dim |
| assertInteger(parts[6]); // medium |
| assertInteger(parts[7]); // light |
| assertInteger(parts[8]); // bright |
| } |
| |
| private void checkSignalStrength(String[] parts) { |
| assertTrue(parts.length >= 9); |
| assertInteger(parts[4]); // none |
| assertInteger(parts[5]); // poor |
| assertInteger(parts[6]); // moderate |
| assertInteger(parts[7]); // good |
| assertInteger(parts[8]); // great |
| } |
| |
| private void checkSignalScanningTime(String[] parts) { |
| assertEquals(5, parts.length); |
| assertInteger(parts[4]); // signalScanningTime |
| } |
| |
| private void checkDataConnection(String[] parts) { |
| assertEquals(26, parts.length); |
| assertInteger(parts[4]); // none |
| assertInteger(parts[5]); // gprs |
| assertInteger(parts[6]); // edge |
| assertInteger(parts[7]); // umts |
| assertInteger(parts[8]); // cdma |
| assertInteger(parts[9]); // evdo_0 |
| assertInteger(parts[10]); // evdo_A |
| assertInteger(parts[11]); // 1xrtt |
| assertInteger(parts[12]); // hsdpa |
| assertInteger(parts[13]); // hsupa |
| assertInteger(parts[14]); // hspa |
| assertInteger(parts[15]); // iden |
| assertInteger(parts[16]); // evdo_b |
| assertInteger(parts[17]); // lte |
| assertInteger(parts[18]); // ehrpd |
| assertInteger(parts[19]); // hspap |
| assertInteger(parts[20]); // gsm |
| assertInteger(parts[21]); // td_scdma |
| assertInteger(parts[22]); // iwlan |
| assertInteger(parts[23]); // lte_ca |
| assertInteger(parts[24]); // nr |
| assertInteger(parts[25]); // other |
| } |
| |
| private void checkWifiState(String[] parts) { |
| assertEquals(12, parts.length); |
| assertInteger(parts[4]); // off |
| assertInteger(parts[5]); // scanning |
| assertInteger(parts[6]); // no_net |
| assertInteger(parts[7]); // disconn |
| assertInteger(parts[8]); // sta |
| assertInteger(parts[9]); // p2p |
| assertInteger(parts[10]); // sta_p2p |
| assertInteger(parts[11]); // soft_ap |
| } |
| |
| private void checkWifiSupplState(String[] parts) { |
| assertEquals(17, parts.length); |
| assertInteger(parts[4]); // inv |
| assertInteger(parts[5]); // dsc |
| assertInteger(parts[6]); // dis |
| assertInteger(parts[7]); // inact |
| assertInteger(parts[8]); // scan |
| assertInteger(parts[9]); // auth |
| assertInteger(parts[10]); // ascing |
| assertInteger(parts[11]); // asced |
| assertInteger(parts[12]); // 4-way |
| assertInteger(parts[13]); // group |
| assertInteger(parts[14]); // compl |
| assertInteger(parts[15]); // dorm |
| assertInteger(parts[16]); // uninit |
| } |
| |
| private void checkWifiSignalStrength(String[] parts) { |
| assertEquals(9, parts.length); |
| assertInteger(parts[4]); // none |
| assertInteger(parts[5]); // poor |
| assertInteger(parts[6]); // moderate |
| assertInteger(parts[7]); // good |
| assertInteger(parts[8]); // great |
| } |
| |
| private void checkBluetoothState(String[] parts) { |
| assertEquals(8, parts.length); |
| assertInteger(parts[4]); // inactive |
| assertInteger(parts[5]); // low |
| assertInteger(parts[6]); // med |
| assertInteger(parts[7]); // high |
| } |
| |
| private void checkPowerUseSummary(String[] parts) { |
| assertEquals(8, parts.length); |
| assertDouble(parts[4]); // batteryCapacity |
| assertDouble(parts[5]); // computedPower |
| assertDouble(parts[6]); // minDrainedPower |
| assertDouble(parts[7]); // maxDrainedPower |
| } |
| |
| private void checkPowerUseItem(String[] parts) { |
| assertEquals(9, parts.length); |
| assertNotNull(parts[4]); // label |
| final double totalPowerMah = assertDouble(parts[5]); // totalPowerMah |
| final long shouldHide = assertInteger(parts[6]); // shouldHide (0 or 1) |
| final double screenPowerMah = assertDouble(parts[7]); // screenPowerMah |
| final double proportionalSmearMah = assertDouble(parts[8]); // proportionalSmearMah |
| |
| assertTrue("powerUseItem totalPowerMah must be >= 0", totalPowerMah >= 0); |
| assertTrue("powerUseItem screenPowerMah must be >= 0", screenPowerMah >= 0); |
| assertTrue("powerUseItem proportionalSmearMah must be >= 0", proportionalSmearMah >= 0); |
| assertTrue("powerUseItem shouldHide must be 0 or 1", shouldHide == 0 || shouldHide == 1); |
| |
| // Largest current Android battery is ~5K. 100K shouldn't get made for a while. |
| assertTrue("powerUseItem totalPowerMah is expected to be <= 100000", totalPowerMah <= 100000); |
| } |
| |
| private void checkChargeDischargeStep(String[] parts) { |
| assertEquals(9, parts.length); |
| assertInteger(parts[4]); // duration |
| if (!parts[5].equals("?")) { |
| assertInteger(parts[5]); // level |
| } |
| assertNotNull(parts[6]); // screen |
| assertNotNull(parts[7]); // power-save |
| assertNotNull(parts[8]); // device-idle |
| } |
| |
| private void checkDischargeTimeRemain(String[] parts) { |
| assertEquals(5, parts.length); |
| assertInteger(parts[4]); // batteryTimeRemaining |
| } |
| |
| private void checkChargeTimeRemain(String[] parts) { |
| assertEquals(5, parts.length); |
| assertInteger(parts[4]); // chargeTimeRemaining |
| } |
| |
| private void checkUidCpuUsage(String[] parts) { |
| assertTrue(parts.length >= 6); |
| assertInteger(parts[4]); // user time |
| assertInteger(parts[5]); // system time |
| } |
| |
| private void checkBluetoothMisc(String[] parts) { |
| assertEquals(15, parts.length); |
| assertInteger(parts[4]); // totalTime |
| assertInteger(parts[5]); // count |
| assertInteger(parts[6]); // countBg |
| assertInteger(parts[7]); // actualTime |
| assertInteger(parts[8]); // actualTimeBg |
| assertInteger(parts[9]); // resultsCount |
| assertInteger(parts[10]); // resultsCountBg |
| assertInteger(parts[11]); // unoptimizedScanTotalTime |
| assertInteger(parts[12]); // unoptimizedScanTotalTimeBg |
| assertInteger(parts[13]); // unoptimizedScanMaxTime |
| assertInteger(parts[14]); // unoptimizedScanMaxTimeBg |
| } |
| |
| /** |
| * Tests the output of "dumpsys gfxinfo framestats". |
| * |
| * @throws Exception |
| */ |
| public void testGfxinfoFramestats() throws Exception { |
| final String MARKER = "---PROFILEDATA---"; |
| |
| try { |
| // cleanup test apps that might be installed from previous partial test run |
| getDevice().uninstallPackage(TEST_PKG); |
| |
| // install the test app |
| CompatibilityBuildHelper buildHelper = new CompatibilityBuildHelper(mCtsBuild); |
| File testAppFile = buildHelper.getTestFile(TEST_APK); |
| String installResult = getDevice().installPackage(testAppFile, false); |
| assertNull( |
| String.format("failed to install atrace test app. Reason: %s", installResult), |
| installResult); |
| |
| getDevice().executeShellCommand("am start -W " + TEST_PKG); |
| |
| String frameinfo = mDevice.executeShellCommand("dumpsys gfxinfo " + |
| TEST_PKG + " framestats"); |
| assertNotNull(frameinfo); |
| assertTrue(frameinfo.length() > 0); |
| int profileStart = frameinfo.indexOf(MARKER); |
| int profileEnd = frameinfo.indexOf(MARKER, profileStart + 1); |
| assertTrue(profileStart >= 0); |
| assertTrue(profileEnd > profileStart); |
| String profileData = frameinfo.substring(profileStart + MARKER.length(), profileEnd); |
| assertTrue(profileData.length() > 0); |
| validateProfileData(profileData); |
| } finally { |
| getDevice().uninstallPackage(TEST_PKG); |
| } |
| } |
| |
| private void validateProfileData(String profileData) throws IOException { |
| final int TIMESTAMP_COUNT = 14; |
| boolean foundAtLeastOneRow = false; |
| try (BufferedReader reader = new BufferedReader( |
| new StringReader(profileData))) { |
| String line; |
| // First line needs to be the headers |
| while ((line = reader.readLine()) != null && line.isEmpty()) {} |
| |
| assertNotNull(line); |
| assertTrue("First line was not the expected header", |
| line.startsWith("Flags,IntendedVsync,Vsync,OldestInputEvent" + |
| ",NewestInputEvent,HandleInputStart,AnimationStart" + |
| ",PerformTraversalsStart,DrawStart,SyncQueued,SyncStart" + |
| ",IssueDrawCommandsStart,SwapBuffers,FrameCompleted")); |
| |
| long[] numparts = new long[TIMESTAMP_COUNT]; |
| while ((line = reader.readLine()) != null && !line.isEmpty()) { |
| |
| String[] parts = line.split(","); |
| assertTrue(parts.length >= TIMESTAMP_COUNT); |
| for (int i = 0; i < TIMESTAMP_COUNT; i++) { |
| numparts[i] = assertInteger(parts[i]); |
| } |
| // Flags = 1 just means the first frame of the window |
| if (numparts[0] != 0 && numparts[0] != 1) { |
| continue; |
| } |
| // assert VSYNC >= INTENDED_VSYNC |
| assertTrue(numparts[2] >= numparts[1]); |
| // assert time is flowing forwards, skipping index 3 & 4 |
| // as those are input timestamps that may or may not be present |
| assertTrue(numparts[5] >= numparts[2]); |
| for (int i = 6; i < TIMESTAMP_COUNT; i++) { |
| assertTrue("Index " + i + " did not flow forward, " + |
| numparts[i] + " not larger than " + numparts[i - 1], |
| numparts[i] >= numparts[i-1]); |
| } |
| long totalDuration = numparts[13] - numparts[1]; |
| assertTrue("Frame did not take a positive amount of time to process", |
| totalDuration > 0); |
| assertTrue("Bogus frame duration, exceeds 100 seconds", |
| totalDuration < 100000000000L); |
| foundAtLeastOneRow = true; |
| } |
| } |
| assertTrue(foundAtLeastOneRow); |
| } |
| } |
