Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2017 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| 5 | * use this file except in compliance with the License. You may obtain a copy of |
| 6 | * 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, WITHOUT |
| 12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 13 | * License for the specific language governing permissions and limitations under |
| 14 | * the License. |
| 15 | */ |
| 16 | package com.android.internal.os; |
| 17 | |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 18 | import static android.os.BatteryStats.STATS_CURRENT; |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 19 | import static android.os.BatteryStats.STATS_SINCE_CHARGED; |
Bookatz | c8c4496 | 2017-05-11 12:12:54 -0700 | [diff] [blame] | 20 | import static android.os.BatteryStats.WAKE_TYPE_PARTIAL; |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 21 | |
Bookatz | c8c4496 | 2017-05-11 12:12:54 -0700 | [diff] [blame] | 22 | import android.app.ActivityManager; |
Mike Ma | c2f518a | 2017-09-19 16:06:03 -0700 | [diff] [blame] | 23 | import android.os.BatteryManager; |
Bookatz | c8c4496 | 2017-05-11 12:12:54 -0700 | [diff] [blame] | 24 | import android.os.BatteryStats; |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 25 | import android.os.BatteryStats.HistoryItem; |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 26 | import android.os.WorkSource; |
| 27 | import android.support.test.filters.SmallTest; |
Mike Ma | c2f518a | 2017-09-19 16:06:03 -0700 | [diff] [blame] | 28 | import android.view.Display; |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 29 | |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 30 | import com.android.internal.os.BatteryStatsImpl.Uid; |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 31 | import junit.framework.TestCase; |
| 32 | |
Michael Wachenschwanz | b05a3c5 | 2017-07-07 17:47:04 -0700 | [diff] [blame] | 33 | import java.util.ArrayList; |
| 34 | import java.util.HashMap; |
| 35 | import java.util.List; |
| 36 | import java.util.Map; |
| 37 | |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 38 | /** |
| 39 | * Test various BatteryStatsImpl noteStart methods. |
Michael Wachenschwanz | b05a3c5 | 2017-07-07 17:47:04 -0700 | [diff] [blame] | 40 | * |
| 41 | * Build/Install/Run: bit FrameworksCoreTests:com.android.internal.os.BatteryStatsNoteTest |
| 42 | * |
| 43 | * Alternatively, |
| 44 | * Build: m FrameworksCoreTests |
| 45 | * Install: adb install -r \ |
| 46 | * ${ANDROID_PRODUCT_OUT}/data/app/FrameworksCoreTests/FrameworksCoreTests.apk |
| 47 | * Run: adb shell am instrument -e class com.android.internal.os.BatteryStatsNoteTest -w \ |
| 48 | * com.android.frameworks.coretests/android.support.test.runner.AndroidJUnitRunner |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 49 | */ |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 50 | public class BatteryStatsNoteTest extends TestCase { |
| 51 | |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 52 | private static final int UID = 10500; |
| 53 | private static final WorkSource WS = new WorkSource(UID); |
| 54 | |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 55 | /** |
| 56 | * Test BatteryStatsImpl.Uid.noteBluetoothScanResultLocked. |
| 57 | */ |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 58 | @SmallTest |
| 59 | public void testNoteBluetoothScanResultLocked() throws Exception { |
| 60 | MockBatteryStatsImpl bi = new MockBatteryStatsImpl(new MockClocks()); |
Mike Ma | c2f518a | 2017-09-19 16:06:03 -0700 | [diff] [blame] | 61 | bi.updateTimeBasesLocked(true, Display.STATE_OFF, 0, 0); |
Bookatz | b1f04f3 | 2017-05-19 13:57:32 -0700 | [diff] [blame] | 62 | bi.noteUidProcessStateLocked(UID, ActivityManager.PROCESS_STATE_TOP); |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 63 | |
Bookatz | 4ebc064 | 2017-05-11 12:21:19 -0700 | [diff] [blame] | 64 | bi.noteBluetoothScanResultsFromSourceLocked(WS, 1); |
| 65 | bi.noteBluetoothScanResultsFromSourceLocked(WS, 100); |
| 66 | assertEquals(101, |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 67 | bi.getUidStats().get(UID).getBluetoothScanResultCounter() |
| 68 | .getCountLocked(STATS_SINCE_CHARGED)); |
Bookatz | b1f04f3 | 2017-05-19 13:57:32 -0700 | [diff] [blame] | 69 | BatteryStats.Counter bgCntr = bi.getUidStats().get(UID).getBluetoothScanResultBgCounter(); |
| 70 | if (bgCntr != null) { |
| 71 | assertEquals(0, bgCntr.getCountLocked(STATS_SINCE_CHARGED)); |
| 72 | } |
| 73 | |
| 74 | bi.noteUidProcessStateLocked(UID, ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND); |
| 75 | bi.noteBluetoothScanResultsFromSourceLocked(WS, 17); |
| 76 | assertEquals(101 + 17, |
| 77 | bi.getUidStats().get(UID).getBluetoothScanResultCounter() |
| 78 | .getCountLocked(STATS_SINCE_CHARGED)); |
| 79 | assertEquals(17, |
| 80 | bi.getUidStats().get(UID).getBluetoothScanResultBgCounter() |
| 81 | .getCountLocked(STATS_SINCE_CHARGED)); |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 82 | } |
Bookatz | c8c4496 | 2017-05-11 12:12:54 -0700 | [diff] [blame] | 83 | |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 84 | /** |
| 85 | * Test BatteryStatsImpl.Uid.noteStartWakeLocked. |
| 86 | */ |
Bookatz | c8c4496 | 2017-05-11 12:12:54 -0700 | [diff] [blame] | 87 | @SmallTest |
| 88 | public void testNoteStartWakeLocked() throws Exception { |
| 89 | final MockClocks clocks = new MockClocks(); // holds realtime and uptime in ms |
| 90 | MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); |
| 91 | |
| 92 | int pid = 10; |
| 93 | String name = "name"; |
| 94 | |
Mike Ma | c2f518a | 2017-09-19 16:06:03 -0700 | [diff] [blame] | 95 | bi.updateTimeBasesLocked(true, Display.STATE_OFF, 0, 0); |
Bookatz | c8c4496 | 2017-05-11 12:12:54 -0700 | [diff] [blame] | 96 | bi.noteUidProcessStateLocked(UID, ActivityManager.PROCESS_STATE_TOP); |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 97 | bi.getUidStatsLocked(UID) |
| 98 | .noteStartWakeLocked(pid, name, WAKE_TYPE_PARTIAL, clocks.realtime); |
Bookatz | c8c4496 | 2017-05-11 12:12:54 -0700 | [diff] [blame] | 99 | |
| 100 | clocks.realtime = clocks.uptime = 100; |
| 101 | bi.noteUidProcessStateLocked(UID, ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND); |
| 102 | |
| 103 | clocks.realtime = clocks.uptime = 220; |
| 104 | bi.getUidStatsLocked(UID).noteStopWakeLocked(pid, name, WAKE_TYPE_PARTIAL, clocks.realtime); |
| 105 | |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 106 | BatteryStats.Timer aggregTimer = bi.getUidStats().get(UID) |
| 107 | .getAggregatedPartialWakelockTimer(); |
Bookatz | c8c4496 | 2017-05-11 12:12:54 -0700 | [diff] [blame] | 108 | long actualTime = aggregTimer.getTotalTimeLocked(300_000, STATS_SINCE_CHARGED); |
| 109 | long bgTime = aggregTimer.getSubTimer().getTotalTimeLocked(300_000, STATS_SINCE_CHARGED); |
| 110 | assertEquals(220_000, actualTime); |
| 111 | assertEquals(120_000, bgTime); |
| 112 | } |
Michael Wachenschwanz | b05a3c5 | 2017-07-07 17:47:04 -0700 | [diff] [blame] | 113 | |
| 114 | |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 115 | /** |
| 116 | * Test BatteryStatsImpl.noteUidProcessStateLocked. |
| 117 | */ |
Michael Wachenschwanz | b05a3c5 | 2017-07-07 17:47:04 -0700 | [diff] [blame] | 118 | @SmallTest |
| 119 | public void testNoteUidProcessStateLocked() throws Exception { |
| 120 | final MockClocks clocks = new MockClocks(); |
| 121 | MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); |
| 122 | |
| 123 | // map of ActivityManager process states and how long to simulate run time in each state |
| 124 | Map<Integer, Integer> stateRuntimeMap = new HashMap<Integer, Integer>(); |
| 125 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_TOP, 1111); |
| 126 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE, 1234); |
| 127 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE, 2468); |
| 128 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_TOP_SLEEPING, 7531); |
| 129 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND, 4455); |
| 130 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_TRANSIENT_BACKGROUND, 1337); |
| 131 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_BACKUP, 90210); |
| 132 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_HEAVY_WEIGHT, 911); |
| 133 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_SERVICE, 404); |
| 134 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_RECEIVER, 31459); |
| 135 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_HOME, 1123); |
| 136 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_LAST_ACTIVITY, 5813); |
| 137 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_CACHED_ACTIVITY, 867); |
| 138 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT, 5309); |
| 139 | stateRuntimeMap.put(ActivityManager.PROCESS_STATE_CACHED_EMPTY, 42); |
| 140 | |
Mike Ma | c2f518a | 2017-09-19 16:06:03 -0700 | [diff] [blame] | 141 | bi.updateTimeBasesLocked(true, Display.STATE_ON, 0, 0); |
Michael Wachenschwanz | b05a3c5 | 2017-07-07 17:47:04 -0700 | [diff] [blame] | 142 | |
| 143 | for (Map.Entry<Integer, Integer> entry : stateRuntimeMap.entrySet()) { |
| 144 | bi.noteUidProcessStateLocked(UID, entry.getKey()); |
| 145 | clocks.realtime += entry.getValue(); |
| 146 | clocks.uptime = clocks.realtime; |
| 147 | } |
| 148 | |
| 149 | long actualRunTimeUs; |
| 150 | long expectedRunTimeMs; |
| 151 | long elapsedTimeUs = clocks.realtime * 1000; |
| 152 | BatteryStats.Uid uid = bi.getUidStats().get(UID); |
| 153 | |
| 154 | // compare runtime of process states to the Uid process states they map to |
| 155 | actualRunTimeUs = uid.getProcessStateTime(BatteryStats.Uid.PROCESS_STATE_TOP, elapsedTimeUs, |
| 156 | STATS_SINCE_CHARGED); |
| 157 | expectedRunTimeMs = stateRuntimeMap.get(ActivityManager.PROCESS_STATE_TOP); |
| 158 | assertEquals(expectedRunTimeMs * 1000, actualRunTimeUs); |
| 159 | |
Michael Wachenschwanz | b05a3c5 | 2017-07-07 17:47:04 -0700 | [diff] [blame] | 160 | actualRunTimeUs = uid.getProcessStateTime(BatteryStats.Uid.PROCESS_STATE_FOREGROUND_SERVICE, |
| 161 | elapsedTimeUs, STATS_SINCE_CHARGED); |
| 162 | expectedRunTimeMs = stateRuntimeMap.get( |
| 163 | ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE) |
| 164 | + stateRuntimeMap.get(ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE); |
| 165 | assertEquals(expectedRunTimeMs * 1000, actualRunTimeUs); |
| 166 | |
Michael Wachenschwanz | b05a3c5 | 2017-07-07 17:47:04 -0700 | [diff] [blame] | 167 | actualRunTimeUs = uid.getProcessStateTime(BatteryStats.Uid.PROCESS_STATE_TOP_SLEEPING, |
| 168 | elapsedTimeUs, STATS_SINCE_CHARGED); |
| 169 | expectedRunTimeMs = stateRuntimeMap.get(ActivityManager.PROCESS_STATE_TOP_SLEEPING); |
| 170 | assertEquals(expectedRunTimeMs * 1000, actualRunTimeUs); |
| 171 | |
Michael Wachenschwanz | b05a3c5 | 2017-07-07 17:47:04 -0700 | [diff] [blame] | 172 | actualRunTimeUs = uid.getProcessStateTime(BatteryStats.Uid.PROCESS_STATE_FOREGROUND, |
| 173 | elapsedTimeUs, STATS_SINCE_CHARGED); |
| 174 | expectedRunTimeMs = stateRuntimeMap.get(ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND); |
| 175 | assertEquals(expectedRunTimeMs * 1000, actualRunTimeUs); |
| 176 | |
Michael Wachenschwanz | b05a3c5 | 2017-07-07 17:47:04 -0700 | [diff] [blame] | 177 | actualRunTimeUs = uid.getProcessStateTime(BatteryStats.Uid.PROCESS_STATE_BACKGROUND, |
| 178 | elapsedTimeUs, STATS_SINCE_CHARGED); |
| 179 | expectedRunTimeMs = stateRuntimeMap.get(ActivityManager.PROCESS_STATE_TRANSIENT_BACKGROUND) |
| 180 | + stateRuntimeMap.get(ActivityManager.PROCESS_STATE_BACKUP) |
Michael Wachenschwanz | b05a3c5 | 2017-07-07 17:47:04 -0700 | [diff] [blame] | 181 | + stateRuntimeMap.get(ActivityManager.PROCESS_STATE_SERVICE) |
| 182 | + stateRuntimeMap.get(ActivityManager.PROCESS_STATE_RECEIVER); |
| 183 | assertEquals(expectedRunTimeMs * 1000, actualRunTimeUs); |
| 184 | |
Michael Wachenschwanz | b05a3c5 | 2017-07-07 17:47:04 -0700 | [diff] [blame] | 185 | actualRunTimeUs = uid.getProcessStateTime(BatteryStats.Uid.PROCESS_STATE_CACHED, |
| 186 | elapsedTimeUs, STATS_SINCE_CHARGED); |
| 187 | expectedRunTimeMs = stateRuntimeMap.get(ActivityManager.PROCESS_STATE_HOME) |
| 188 | + stateRuntimeMap.get(ActivityManager.PROCESS_STATE_LAST_ACTIVITY) |
| 189 | + stateRuntimeMap.get(ActivityManager.PROCESS_STATE_CACHED_ACTIVITY) |
| 190 | + stateRuntimeMap.get(ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT) |
| 191 | + stateRuntimeMap.get(ActivityManager.PROCESS_STATE_CACHED_EMPTY); |
| 192 | assertEquals(expectedRunTimeMs * 1000, actualRunTimeUs); |
| 193 | |
| 194 | // Special check for foreground service timer |
| 195 | actualRunTimeUs = uid.getForegroundServiceTimer().getTotalTimeLocked(elapsedTimeUs, |
| 196 | STATS_SINCE_CHARGED); |
| 197 | expectedRunTimeMs = stateRuntimeMap.get(ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE); |
| 198 | assertEquals(expectedRunTimeMs * 1000, actualRunTimeUs); |
| 199 | } |
Mike Ma | c2f518a | 2017-09-19 16:06:03 -0700 | [diff] [blame] | 200 | |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 201 | /** |
| 202 | * Test BatteryStatsImpl.updateTimeBasesLocked. |
| 203 | */ |
Mike Ma | c2f518a | 2017-09-19 16:06:03 -0700 | [diff] [blame] | 204 | @SmallTest |
| 205 | public void testUpdateTimeBasesLocked() throws Exception { |
| 206 | final MockClocks clocks = new MockClocks(); // holds realtime and uptime in ms |
| 207 | MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); |
| 208 | |
| 209 | bi.updateTimeBasesLocked(false, Display.STATE_OFF, 0, 0); |
| 210 | assertFalse(bi.getOnBatteryTimeBase().isRunning()); |
| 211 | bi.updateTimeBasesLocked(false, Display.STATE_DOZE, 10, 10); |
| 212 | assertFalse(bi.getOnBatteryTimeBase().isRunning()); |
| 213 | bi.updateTimeBasesLocked(false, Display.STATE_ON, 20, 20); |
| 214 | assertFalse(bi.getOnBatteryTimeBase().isRunning()); |
| 215 | |
| 216 | bi.updateTimeBasesLocked(true, Display.STATE_ON, 30, 30); |
| 217 | assertTrue(bi.getOnBatteryTimeBase().isRunning()); |
| 218 | assertFalse(bi.getOnBatteryScreenOffTimeBase().isRunning()); |
| 219 | bi.updateTimeBasesLocked(true, Display.STATE_DOZE, 40, 40); |
| 220 | assertTrue(bi.getOnBatteryScreenOffTimeBase().isRunning()); |
| 221 | bi.updateTimeBasesLocked(true, Display.STATE_OFF, 40, 40); |
| 222 | assertTrue(bi.getOnBatteryScreenOffTimeBase().isRunning()); |
| 223 | } |
| 224 | |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 225 | /** |
| 226 | * Test BatteryStatsImpl.noteScreenStateLocked sets timebases and screen states correctly. |
| 227 | */ |
Mike Ma | c2f518a | 2017-09-19 16:06:03 -0700 | [diff] [blame] | 228 | @SmallTest |
| 229 | public void testNoteScreenStateLocked() throws Exception { |
| 230 | final MockClocks clocks = new MockClocks(); // holds realtime and uptime in ms |
| 231 | MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); |
| 232 | |
| 233 | bi.updateTimeBasesLocked(true, Display.STATE_ON, 0, 0); |
| 234 | bi.noteScreenStateLocked(Display.STATE_ON); |
| 235 | bi.noteScreenStateLocked(Display.STATE_DOZE); |
| 236 | assertTrue(bi.getOnBatteryScreenOffTimeBase().isRunning()); |
| 237 | assertEquals(bi.getScreenState(), Display.STATE_DOZE); |
| 238 | bi.noteScreenStateLocked(Display.STATE_ON); |
| 239 | assertFalse(bi.getOnBatteryScreenOffTimeBase().isRunning()); |
| 240 | assertEquals(bi.getScreenState(), Display.STATE_ON); |
| 241 | bi.noteScreenStateLocked(Display.STATE_OFF); |
| 242 | assertTrue(bi.getOnBatteryScreenOffTimeBase().isRunning()); |
| 243 | assertEquals(bi.getScreenState(), Display.STATE_OFF); |
| 244 | } |
| 245 | |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 246 | /** |
| 247 | * Test BatteryStatsImpl.noteScreenStateLocked updates timers correctly. |
Mike Ma | a772475 | 2017-10-10 15:29:25 -0700 | [diff] [blame] | 248 | * |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 249 | * Unknown and doze should both be subset of off state |
Mike Ma | a772475 | 2017-10-10 15:29:25 -0700 | [diff] [blame] | 250 | * |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 251 | * Timeline 0----100----200----310----400------------1000 Unknown ------- On ------- Off |
| 252 | * ------- ---------------------- Doze ---------------- |
Mike Ma | a772475 | 2017-10-10 15:29:25 -0700 | [diff] [blame] | 253 | */ |
| 254 | @SmallTest |
| 255 | public void testNoteScreenStateTimersLocked() throws Exception { |
| 256 | final MockClocks clocks = new MockClocks(); // holds realtime and uptime in ms |
| 257 | MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); |
| 258 | |
| 259 | clocks.realtime = clocks.uptime = 100; |
| 260 | // Device startup, setOnBatteryLocked calls updateTimebases |
| 261 | bi.updateTimeBasesLocked(true, Display.STATE_UNKNOWN, 100_000, 100_000); |
| 262 | // Turn on display at 200us |
| 263 | clocks.realtime = clocks.uptime = 200; |
| 264 | bi.noteScreenStateLocked(Display.STATE_ON); |
| 265 | assertEquals(150_000, bi.computeBatteryRealtime(250_000, STATS_SINCE_CHARGED)); |
| 266 | assertEquals(100_000, bi.computeBatteryScreenOffRealtime(250_000, STATS_SINCE_CHARGED)); |
| 267 | assertEquals(50_000, bi.getScreenOnTime(250_000, STATS_SINCE_CHARGED)); |
| 268 | assertEquals(0, bi.getScreenDozeTime(250_000, STATS_SINCE_CHARGED)); |
| 269 | |
| 270 | clocks.realtime = clocks.uptime = 310; |
| 271 | bi.noteScreenStateLocked(Display.STATE_OFF); |
| 272 | assertEquals(250_000, bi.computeBatteryRealtime(350_000, STATS_SINCE_CHARGED)); |
| 273 | assertEquals(140_000, bi.computeBatteryScreenOffRealtime(350_000, STATS_SINCE_CHARGED)); |
| 274 | assertEquals(110_000, bi.getScreenOnTime(350_000, STATS_SINCE_CHARGED)); |
| 275 | assertEquals(0, bi.getScreenDozeTime(350_000, STATS_SINCE_CHARGED)); |
| 276 | |
| 277 | clocks.realtime = clocks.uptime = 400; |
| 278 | bi.noteScreenStateLocked(Display.STATE_DOZE); |
| 279 | assertEquals(400_000, bi.computeBatteryRealtime(500_000, STATS_SINCE_CHARGED)); |
| 280 | assertEquals(290_000, bi.computeBatteryScreenOffRealtime(500_000, STATS_SINCE_CHARGED)); |
| 281 | assertEquals(110_000, bi.getScreenOnTime(500_000, STATS_SINCE_CHARGED)); |
| 282 | assertEquals(100_000, bi.getScreenDozeTime(500_000, STATS_SINCE_CHARGED)); |
| 283 | |
| 284 | clocks.realtime = clocks.uptime = 1000; |
| 285 | bi.noteScreenStateLocked(Display.STATE_OFF); |
| 286 | assertEquals(1400_000, bi.computeBatteryRealtime(1500_000, STATS_SINCE_CHARGED)); |
| 287 | assertEquals(1290_000, bi.computeBatteryScreenOffRealtime(1500_000, STATS_SINCE_CHARGED)); |
| 288 | assertEquals(110_000, bi.getScreenOnTime(1500_000, STATS_SINCE_CHARGED)); |
| 289 | assertEquals(600_000, bi.getScreenDozeTime(1500_000, STATS_SINCE_CHARGED)); |
| 290 | } |
| 291 | |
Narayan Kamath | 695cf72 | 2017-12-21 18:32:47 +0000 | [diff] [blame] | 292 | @SmallTest |
| 293 | public void testAlarmStartAndFinishLocked() throws Exception { |
| 294 | final MockClocks clocks = new MockClocks(); // holds realtime and uptime in ms |
| 295 | MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); |
| 296 | bi.setRecordAllHistoryLocked(true); |
| 297 | bi.forceRecordAllHistory(); |
| 298 | |
| 299 | bi.updateTimeBasesLocked(true, Display.STATE_OFF, 0, 0); |
| 300 | bi.noteUidProcessStateLocked(UID, ActivityManager.PROCESS_STATE_TOP); |
| 301 | |
| 302 | clocks.realtime = clocks.uptime = 100; |
| 303 | bi.noteAlarmStartLocked("foo", null, UID); |
| 304 | clocks.realtime = clocks.uptime = 5000; |
| 305 | bi.noteAlarmFinishLocked("foo", null, UID); |
| 306 | |
| 307 | HistoryItem item = new HistoryItem(); |
| 308 | assertTrue(bi.startIteratingHistoryLocked()); |
| 309 | |
| 310 | assertTrue(bi.getNextHistoryLocked(item)); |
| 311 | assertEquals(HistoryItem.EVENT_ALARM_START, item.eventCode); |
| 312 | assertEquals("foo", item.eventTag.string); |
| 313 | assertEquals(UID, item.eventTag.uid); |
| 314 | |
| 315 | // TODO(narayan): Figure out why this event is written to the history buffer. See |
| 316 | // test below where it is being interspersed between multiple START events too. |
| 317 | assertTrue(bi.getNextHistoryLocked(item)); |
| 318 | assertEquals(HistoryItem.EVENT_NONE, item.eventCode); |
| 319 | |
| 320 | assertTrue(bi.getNextHistoryLocked(item)); |
| 321 | assertEquals(HistoryItem.EVENT_ALARM_FINISH, item.eventCode); |
| 322 | assertTrue(item.isDeltaData()); |
| 323 | assertEquals("foo", item.eventTag.string); |
| 324 | assertEquals(UID, item.eventTag.uid); |
| 325 | |
| 326 | assertFalse(bi.getNextHistoryLocked(item)); |
| 327 | } |
| 328 | |
| 329 | @SmallTest |
| 330 | public void testAlarmStartAndFinishLocked_workSource() throws Exception { |
| 331 | final MockClocks clocks = new MockClocks(); // holds realtime and uptime in ms |
| 332 | MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); |
| 333 | bi.setRecordAllHistoryLocked(true); |
| 334 | bi.forceRecordAllHistory(); |
| 335 | |
| 336 | bi.updateTimeBasesLocked(true, Display.STATE_OFF, 0, 0); |
| 337 | bi.noteUidProcessStateLocked(UID, ActivityManager.PROCESS_STATE_TOP); |
| 338 | |
| 339 | WorkSource ws = new WorkSource(); |
| 340 | ws.add(100); |
| 341 | ws.createWorkChain().addNode(500, "tag"); |
| 342 | bi.noteAlarmStartLocked("foo", ws, UID); |
| 343 | clocks.realtime = clocks.uptime = 5000; |
| 344 | bi.noteAlarmFinishLocked("foo", ws, UID); |
| 345 | |
| 346 | HistoryItem item = new HistoryItem(); |
| 347 | assertTrue(bi.startIteratingHistoryLocked()); |
| 348 | |
| 349 | assertTrue(bi.getNextHistoryLocked(item)); |
| 350 | assertEquals(HistoryItem.EVENT_ALARM_START, item.eventCode); |
| 351 | assertEquals("foo", item.eventTag.string); |
| 352 | assertEquals(100, item.eventTag.uid); |
| 353 | |
| 354 | assertTrue(bi.getNextHistoryLocked(item)); |
| 355 | assertEquals(HistoryItem.EVENT_NONE, item.eventCode); |
| 356 | |
| 357 | assertTrue(bi.getNextHistoryLocked(item)); |
| 358 | assertEquals(HistoryItem.EVENT_ALARM_START, item.eventCode); |
| 359 | assertEquals("foo", item.eventTag.string); |
| 360 | assertEquals(500, item.eventTag.uid); |
| 361 | |
| 362 | assertTrue(bi.getNextHistoryLocked(item)); |
| 363 | assertEquals(HistoryItem.EVENT_ALARM_FINISH, item.eventCode); |
| 364 | assertEquals("foo", item.eventTag.string); |
| 365 | assertEquals(100, item.eventTag.uid); |
| 366 | |
| 367 | assertTrue(bi.getNextHistoryLocked(item)); |
| 368 | assertEquals(HistoryItem.EVENT_ALARM_FINISH, item.eventCode); |
| 369 | assertEquals("foo", item.eventTag.string); |
| 370 | assertEquals(500, item.eventTag.uid); |
| 371 | } |
| 372 | |
| 373 | @SmallTest |
| 374 | public void testNoteWakupAlarmLocked() { |
| 375 | final MockClocks clocks = new MockClocks(); // holds realtime and uptime in ms |
| 376 | MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); |
| 377 | bi.setRecordAllHistoryLocked(true); |
| 378 | bi.forceRecordAllHistory(); |
| 379 | bi.mForceOnBattery = true; |
| 380 | |
| 381 | bi.updateTimeBasesLocked(true, Display.STATE_OFF, 0, 0); |
| 382 | bi.noteUidProcessStateLocked(UID, ActivityManager.PROCESS_STATE_TOP); |
| 383 | |
| 384 | bi.noteWakupAlarmLocked("com.foo.bar", UID, null, "tag"); |
| 385 | |
| 386 | Uid.Pkg pkg = bi.getPackageStatsLocked(UID, "com.foo.bar"); |
| 387 | assertEquals(1, pkg.getWakeupAlarmStats().get("tag").getCountLocked(STATS_CURRENT)); |
| 388 | assertEquals(1, pkg.getWakeupAlarmStats().size()); |
| 389 | } |
| 390 | |
| 391 | @SmallTest |
| 392 | public void testNoteWakupAlarmLocked_workSource_uid() { |
| 393 | final MockClocks clocks = new MockClocks(); // holds realtime and uptime in ms |
| 394 | MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); |
| 395 | bi.setRecordAllHistoryLocked(true); |
| 396 | bi.forceRecordAllHistory(); |
| 397 | bi.mForceOnBattery = true; |
| 398 | |
| 399 | bi.updateTimeBasesLocked(true, Display.STATE_OFF, 0, 0); |
| 400 | bi.noteUidProcessStateLocked(UID, ActivityManager.PROCESS_STATE_TOP); |
| 401 | |
| 402 | WorkSource ws = new WorkSource(); |
| 403 | ws.add(100); |
| 404 | |
| 405 | // When a WorkSource is present, "UID" should not be used - only the uids present in the |
| 406 | // WorkSource should be reported. |
| 407 | bi.noteWakupAlarmLocked("com.foo.bar", UID, ws, "tag"); |
| 408 | Uid.Pkg pkg = bi.getPackageStatsLocked(UID, "com.foo.bar"); |
| 409 | assertEquals(0, pkg.getWakeupAlarmStats().size()); |
| 410 | pkg = bi.getPackageStatsLocked(100, "com.foo.bar"); |
| 411 | assertEquals(1, pkg.getWakeupAlarmStats().size()); |
| 412 | |
| 413 | // If the WorkSource contains a "name", it should be interpreted as a package name and |
| 414 | // the packageName supplied as an argument must be ignored. |
| 415 | ws = new WorkSource(); |
| 416 | ws.add(100, "com.foo.baz_alternate"); |
| 417 | bi.noteWakupAlarmLocked("com.foo.baz", UID, ws, "tag"); |
| 418 | pkg = bi.getPackageStatsLocked(100, "com.foo.baz"); |
| 419 | assertEquals(0, pkg.getWakeupAlarmStats().size()); |
| 420 | pkg = bi.getPackageStatsLocked(100, "com.foo.baz_alternate"); |
| 421 | assertEquals(1, pkg.getWakeupAlarmStats().size()); |
| 422 | } |
| 423 | |
| 424 | @SmallTest |
| 425 | public void testNoteWakupAlarmLocked_workSource_workChain() { |
| 426 | final MockClocks clocks = new MockClocks(); // holds realtime and uptime in ms |
| 427 | MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); |
| 428 | bi.setRecordAllHistoryLocked(true); |
| 429 | bi.forceRecordAllHistory(); |
| 430 | bi.mForceOnBattery = true; |
| 431 | |
| 432 | bi.updateTimeBasesLocked(true, Display.STATE_OFF, 0, 0); |
| 433 | bi.noteUidProcessStateLocked(UID, ActivityManager.PROCESS_STATE_TOP); |
| 434 | |
| 435 | WorkSource ws = new WorkSource(); |
| 436 | ws.createWorkChain().addNode(100, "com.foo.baz_alternate"); |
| 437 | bi.noteWakupAlarmLocked("com.foo.bar", UID, ws, "tag"); |
| 438 | |
| 439 | // For WorkChains, again we must only attribute to the uids present in the WorkSource |
| 440 | // (and not to "UID"). However, unlike the older "tags" we do not change the packagename |
| 441 | // supplied as an argument, given that we're logging the entire attribution chain. |
| 442 | Uid.Pkg pkg = bi.getPackageStatsLocked(UID, "com.foo.bar"); |
| 443 | assertEquals(0, pkg.getWakeupAlarmStats().size()); |
| 444 | pkg = bi.getPackageStatsLocked(100, "com.foo.bar"); |
| 445 | assertEquals(1, pkg.getWakeupAlarmStats().size()); |
| 446 | pkg = bi.getPackageStatsLocked(100, "com.foo.baz_alternate"); |
| 447 | assertEquals(0, pkg.getWakeupAlarmStats().size()); |
| 448 | } |
Bookatz | 956f36bf | 2017-04-28 09:48:17 -0700 | [diff] [blame] | 449 | } |