Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / frameworks / base / d02044c3ce91fc396aed87a7dc7a126b52f89b32 / . / services / tests / mockingservicestests / src / com / android / server / am / MockingOomAdjusterTests.java
blob: 2983d585c45a5cb34e9493557492f38dc2ccf439 [file] [log] [blame]
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]1/*
2 * Copyright (C) 2019 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
17package com.android.server.am;
18
19import static android.app.ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE;
20import static android.app.ActivityManager.PROCESS_STATE_BOUND_TOP;
21import static android.app.ActivityManager.PROCESS_STATE_CACHED_ACTIVITY;
22import static android.app.ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT;
23import static android.app.ActivityManager.PROCESS_STATE_CACHED_EMPTY;
24import static android.app.ActivityManager.PROCESS_STATE_CACHED_RECENT;
25import static android.app.ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE;
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]26import static android.app.ActivityManager.PROCESS_STATE_HEAVY_WEIGHT;
27import static android.app.ActivityManager.PROCESS_STATE_HOME;
28import static android.app.ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND;
29import static android.app.ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND;
30import static android.app.ActivityManager.PROCESS_STATE_LAST_ACTIVITY;
31import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT;
32import static android.app.ActivityManager.PROCESS_STATE_PERSISTENT_UI;
33import static android.app.ActivityManager.PROCESS_STATE_RECEIVER;
34import static android.app.ActivityManager.PROCESS_STATE_SERVICE;
35import static android.app.ActivityManager.PROCESS_STATE_TOP;
36import static android.app.ActivityManager.PROCESS_STATE_TOP_SLEEPING;
37import static android.app.ActivityManager.PROCESS_STATE_TRANSIENT_BACKGROUND;
38
39import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;
40
41import static com.android.server.am.ProcessList.BACKUP_APP_ADJ;
42import static com.android.server.am.ProcessList.CACHED_APP_MAX_ADJ;
43import static com.android.server.am.ProcessList.CACHED_APP_MIN_ADJ;
44import static com.android.server.am.ProcessList.FOREGROUND_APP_ADJ;
45import static com.android.server.am.ProcessList.HEAVY_WEIGHT_APP_ADJ;
46import static com.android.server.am.ProcessList.HOME_APP_ADJ;
47import static com.android.server.am.ProcessList.PERCEPTIBLE_APP_ADJ;
48import static com.android.server.am.ProcessList.PERCEPTIBLE_LOW_APP_ADJ;
49import static com.android.server.am.ProcessList.PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ;
50import static com.android.server.am.ProcessList.PERSISTENT_PROC_ADJ;
51import static com.android.server.am.ProcessList.PERSISTENT_SERVICE_ADJ;
52import static com.android.server.am.ProcessList.PREVIOUS_APP_ADJ;
53import static com.android.server.am.ProcessList.SCHED_GROUP_BACKGROUND;
54import static com.android.server.am.ProcessList.SCHED_GROUP_DEFAULT;
55import static com.android.server.am.ProcessList.SCHED_GROUP_RESTRICTED;
56import static com.android.server.am.ProcessList.SCHED_GROUP_TOP_APP;
57import static com.android.server.am.ProcessList.SCHED_GROUP_TOP_APP_BOUND;
58import static com.android.server.am.ProcessList.SERVICE_ADJ;
59import static com.android.server.am.ProcessList.SERVICE_B_ADJ;
60import static com.android.server.am.ProcessList.UNKNOWN_ADJ;
61import static com.android.server.am.ProcessList.VISIBLE_APP_ADJ;
62
63import static org.junit.Assert.assertEquals;
Jing Ji057f4cb2019-11-01 13:23:11 -0700[diff] [blame]64import static org.junit.Assert.assertTrue;
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]65import static org.mockito.AdditionalAnswers.answer;
66import static org.mockito.Mockito.any;
67import static org.mockito.Mockito.anyInt;
68import static org.mockito.Mockito.anyLong;
69import static org.mockito.Mockito.doAnswer;
70import static org.mockito.Mockito.doCallRealMethod;
71import static org.mockito.Mockito.doNothing;
72import static org.mockito.Mockito.doReturn;
73import static org.mockito.Mockito.mock;
74import static org.mockito.Mockito.spy;
75
76import android.app.IApplicationThread;
77import android.app.IServiceConnection;
Darryl L Johnsona0982222020-02-18 18:21:51 -0800[diff] [blame]78import android.content.ComponentName;
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]79import android.content.Context;
80import android.content.pm.ApplicationInfo;
Darryl L Johnsona0982222020-02-18 18:21:51 -0800[diff] [blame]81import android.content.pm.PackageManagerInternal;
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]82import android.content.pm.ServiceInfo;
83import android.os.Build;
84import android.os.IBinder;
85import android.os.PowerManagerInternal;
86import android.os.SystemClock;
Sudheer Shankada0ee7f2019-10-01 17:05:31 -0700[diff] [blame]87import android.platform.test.annotations.Presubmit;
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]88import android.util.ArrayMap;
89import android.util.ArraySet;
90import android.util.SparseArray;
91
Darryl L Johnsona0982222020-02-18 18:21:51 -0800[diff] [blame]92import com.android.server.LocalServices;
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]93import com.android.server.wm.ActivityServiceConnectionsHolder;
94import com.android.server.wm.ActivityTaskManagerService;
95import com.android.server.wm.WindowProcessController;
96
Jing Ji04a3cfb2020-03-14 00:40:49 -0700[diff] [blame]97import org.junit.AfterClass;
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]98import org.junit.BeforeClass;
99import org.junit.Test;
100
101import java.lang.reflect.Field;
102import java.lang.reflect.Modifier;
103import java.util.ArrayList;
104
105/**
106 * Test class for {@link OomAdjuster}.
107 *
108 * Build/Install/Run:
109 * atest MockingOomAdjusterTests
110 */
Sudheer Shankada0ee7f2019-10-01 17:05:31 -0700[diff] [blame]111@Presubmit
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]112public class MockingOomAdjusterTests {
113 private static final int MOCKAPP_PID = 12345;
114 private static final int MOCKAPP_UID = 12345;
115 private static final String MOCKAPP_PROCESSNAME = "test #1";
116 private static final String MOCKAPP_PACKAGENAME = "com.android.test.test1";
117 private static final int MOCKAPP2_PID = MOCKAPP_PID + 1;
118 private static final int MOCKAPP2_UID = MOCKAPP_UID + 1;
119 private static final String MOCKAPP2_PROCESSNAME = "test #2";
120 private static final String MOCKAPP2_PACKAGENAME = "com.android.test.test2";
121 private static final int MOCKAPP3_PID = MOCKAPP_PID + 2;
122 private static final int MOCKAPP3_UID = MOCKAPP_UID + 2;
123 private static final String MOCKAPP3_PROCESSNAME = "test #3";
124 private static final String MOCKAPP3_PACKAGENAME = "com.android.test.test3";
125 private static final int MOCKAPP4_PID = MOCKAPP_PID + 3;
126 private static final int MOCKAPP4_UID = MOCKAPP_UID + 3;
127 private static final String MOCKAPP4_PROCESSNAME = "test #4";
128 private static final String MOCKAPP4_PACKAGENAME = "com.android.test.test4";
129 private static final int MOCKAPP5_PID = MOCKAPP_PID + 4;
130 private static final int MOCKAPP5_UID = MOCKAPP_UID + 4;
131 private static final String MOCKAPP5_PROCESSNAME = "test #5";
132 private static final String MOCKAPP5_PACKAGENAME = "com.android.test.test5";
133 private static Context sContext;
Darryl L Johnsona0982222020-02-18 18:21:51 -0800[diff] [blame]134 private static PackageManagerInternal sPackageManagerInternal;
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]135 private static ActivityManagerService sService;
136
137 @BeforeClass
138 public static void setUpOnce() {
139 sContext = getInstrumentation().getTargetContext();
140 System.setProperty("dexmaker.share_classloader", "true");
141
Darryl L Johnsona0982222020-02-18 18:21:51 -0800[diff] [blame]142 sPackageManagerInternal = mock(PackageManagerInternal.class);
143 doReturn(new ComponentName("", "")).when(sPackageManagerInternal)
144 .getSystemUiServiceComponent();
Jing Ji04a3cfb2020-03-14 00:40:49 -0700[diff] [blame]145 // Remove stale instance of PackageManagerInternal if there is any
146 LocalServices.removeServiceForTest(PackageManagerInternal.class);
Darryl L Johnsona0982222020-02-18 18:21:51 -0800[diff] [blame]147 LocalServices.addService(PackageManagerInternal.class, sPackageManagerInternal);
148
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]149 sService = mock(ActivityManagerService.class);
150 sService.mActivityTaskManager = new ActivityTaskManagerService(sContext);
151 sService.mActivityTaskManager.initialize(null, null, sContext.getMainLooper());
Darryl L Johnsona0982222020-02-18 18:21:51 -0800[diff] [blame]152 sService.mPackageManagerInt = sPackageManagerInternal;
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]153 sService.mAtmInternal = spy(sService.mActivityTaskManager.getAtmInternal());
154
155 sService.mConstants = new ActivityManagerConstants(sContext, sService,
156 sContext.getMainThreadHandler());
Jing Ji9b204362020-03-12 11:42:34 -0700[diff] [blame]157 setFieldValue(ActivityManagerService.class, sService, "mContext",
158 sContext);
Jing Ji094c3ef2019-08-27 17:02:09 -0700[diff] [blame]159 ProcessList pr = new ProcessList();
atrost5ae996f2019-12-11 18:32:48 +0000[diff] [blame]160 pr.init(sService, new ActiveUids(sService, false), null);
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]161 setFieldValue(ActivityManagerService.class, sService, "mProcessList",
Jing Ji094c3ef2019-08-27 17:02:09 -0700[diff] [blame]162 pr);
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]163 setFieldValue(ActivityManagerService.class, sService, "mHandler",
164 mock(ActivityManagerService.MainHandler.class));
165 setFieldValue(ActivityManagerService.class, sService, "mProcessStats",
166 mock(ProcessStatsService.class));
167 setFieldValue(ActivityManagerService.class, sService, "mBackupTargets",
168 mock(SparseArray.class));
169 setFieldValue(ActivityManagerService.class, sService, "mOomAdjProfiler",
170 mock(OomAdjProfiler.class));
171 doReturn(new ActivityManagerService.ProcessChangeItem()).when(sService)
172 .enqueueProcessChangeItemLocked(anyInt(), anyInt());
173 sService.mOomAdjuster = new OomAdjuster(sService, sService.mProcessList,
174 mock(ActiveUids.class));
175 sService.mOomAdjuster.mAdjSeq = 10000;
176 }
177
Jing Ji04a3cfb2020-03-14 00:40:49 -0700[diff] [blame]178 @AfterClass
179 public static void tearDownOnce() {
180 LocalServices.removeServiceForTest(PackageManagerInternal.class);
181 }
182
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]183 private static <T> void setFieldValue(Class clazz, Object obj, String fieldName, T val) {
184 try {
185 Field field = clazz.getDeclaredField(fieldName);
186 field.setAccessible(true);
187 Field mfield = Field.class.getDeclaredField("accessFlags");
188 mfield.setAccessible(true);
189 mfield.setInt(field, mfield.getInt(field) & ~(Modifier.FINAL | Modifier.PRIVATE));
190 field.set(obj, val);
191 } catch (NoSuchFieldException | IllegalAccessException e) {
192 }
193 }
194
195 @SuppressWarnings("GuardedBy")
196 @Test
197 public void testUpdateOomAdj_DoOne_Persistent_TopUi_Sleeping() {
198 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
199 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
200 app.maxAdj = PERSISTENT_PROC_ADJ;
201 app.setHasTopUi(true);
202 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_ASLEEP;
203 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
204 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
205
206 assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERSISTENT_PROC_ADJ,
207 SCHED_GROUP_RESTRICTED);
208 }
209
210 @SuppressWarnings("GuardedBy")
211 @Test
212 public void testUpdateOomAdj_DoOne_Persistent_TopUi_Awake() {
213 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
214 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
215 app.maxAdj = PERSISTENT_PROC_ADJ;
216 app.setHasTopUi(true);
217 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
218 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
219
220 assertProcStates(app, PROCESS_STATE_PERSISTENT_UI, PERSISTENT_PROC_ADJ,
221 SCHED_GROUP_TOP_APP);
222 }
223
224 @SuppressWarnings("GuardedBy")
225 @Test
226 public void testUpdateOomAdj_DoOne_Persistent_TopApp() {
227 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
228 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
229 app.maxAdj = PERSISTENT_PROC_ADJ;
230 doReturn(app).when(sService).getTopAppLocked();
231 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
232 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
233 doReturn(null).when(sService).getTopAppLocked();
234
235 assertProcStates(app, PROCESS_STATE_PERSISTENT_UI, PERSISTENT_PROC_ADJ,
236 SCHED_GROUP_TOP_APP);
237 }
238
239 @SuppressWarnings("GuardedBy")
240 @Test
241 public void testUpdateOomAdj_DoOne_TopApp_Awake() {
242 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
243 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
244 doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
245 doReturn(app).when(sService).getTopAppLocked();
246 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
247 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
248 doReturn(null).when(sService).getTopAppLocked();
249
250 assertProcStates(app, PROCESS_STATE_TOP, FOREGROUND_APP_ADJ, SCHED_GROUP_TOP_APP);
251 }
252
253 @SuppressWarnings("GuardedBy")
254 @Test
255 public void testUpdateOomAdj_DoOne_RunningAnimations() {
256 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
257 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
258 doReturn(PROCESS_STATE_TOP_SLEEPING).when(sService.mAtmInternal).getTopProcessState();
259 app.runningRemoteAnimation = true;
260 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
261 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
262 doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
263
264 assertProcStates(app, PROCESS_STATE_TOP_SLEEPING, VISIBLE_APP_ADJ, SCHED_GROUP_TOP_APP);
265 }
266
267 @SuppressWarnings("GuardedBy")
268 @Test
269 public void testUpdateOomAdj_DoOne_RunningInstrumentation() {
270 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
271 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
272 doReturn(mock(ActiveInstrumentation.class)).when(app).getActiveInstrumentation();
273 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
274 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
275 doCallRealMethod().when(app).getActiveInstrumentation();
276
277 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, FOREGROUND_APP_ADJ,
278 SCHED_GROUP_DEFAULT);
279 }
280
281 @SuppressWarnings("GuardedBy")
282 @Test
283 public void testUpdateOomAdj_DoOne_ReceivingBroadcast() {
284 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
285 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
286 doReturn(true).when(sService).isReceivingBroadcastLocked(any(ProcessRecord.class),
287 any(ArraySet.class));
288 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
289 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
290 doReturn(false).when(sService).isReceivingBroadcastLocked(any(ProcessRecord.class),
291 any(ArraySet.class));
292
293 assertProcStates(app, PROCESS_STATE_RECEIVER, FOREGROUND_APP_ADJ, SCHED_GROUP_BACKGROUND);
294 }
295
296 @SuppressWarnings("GuardedBy")
297 @Test
298 public void testUpdateOomAdj_DoOne_ExecutingService() {
299 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
300 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
301 app.executingServices.add(mock(ServiceRecord.class));
302 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
303 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
304
305 assertProcStates(app, PROCESS_STATE_SERVICE, FOREGROUND_APP_ADJ, SCHED_GROUP_BACKGROUND);
306 }
307
308 @SuppressWarnings("GuardedBy")
309 @Test
310 public void testUpdateOomAdj_DoOne_TopApp_Sleeping() {
311 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
312 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
313 doReturn(PROCESS_STATE_TOP_SLEEPING).when(sService.mAtmInternal).getTopProcessState();
314 doReturn(app).when(sService).getTopAppLocked();
315 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_ASLEEP;
316 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
317 doReturn(null).when(sService).getTopAppLocked();
318 doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
319 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
320
321 assertProcStates(app, PROCESS_STATE_TOP_SLEEPING, FOREGROUND_APP_ADJ,
322 SCHED_GROUP_BACKGROUND);
323 }
324
325 @SuppressWarnings("GuardedBy")
326 @Test
327 public void testUpdateOomAdj_DoOne_CachedEmpty() {
328 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
329 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
330 app.setCurRawAdj(CACHED_APP_MIN_ADJ);
331 doReturn(null).when(sService).getTopAppLocked();
332 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
333 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
334
335 assertProcStates(app, PROCESS_STATE_CACHED_EMPTY, CACHED_APP_MIN_ADJ,
336 SCHED_GROUP_BACKGROUND);
337 }
338
339 @SuppressWarnings("GuardedBy")
340 @Test
341 public void testUpdateOomAdj_DoOne_VisibleActivities() {
342 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
343 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
344 doReturn(mock(WindowProcessController.class)).when(app).getWindowProcessController();
345 WindowProcessController wpc = app.getWindowProcessController();
346 doReturn(true).when(wpc).hasActivities();
347 doAnswer(answer((minTaskLayer, callback) -> {
348 Field field = callback.getClass().getDeclaredField("adj");
349 field.set(callback, VISIBLE_APP_ADJ);
350 field = callback.getClass().getDeclaredField("foregroundActivities");
351 field.set(callback, true);
352 field = callback.getClass().getDeclaredField("procState");
353 field.set(callback, PROCESS_STATE_TOP);
354 field = callback.getClass().getDeclaredField("schedGroup");
355 field.set(callback, SCHED_GROUP_TOP_APP);
356 return 0;
357 })).when(wpc).computeOomAdjFromActivities(anyInt(),
358 any(WindowProcessController.ComputeOomAdjCallback.class));
359 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
360 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
361 doCallRealMethod().when(app).getWindowProcessController();
362
363 assertProcStates(app, PROCESS_STATE_TOP, VISIBLE_APP_ADJ, SCHED_GROUP_TOP_APP);
364 }
365
366 @SuppressWarnings("GuardedBy")
367 @Test
368 public void testUpdateOomAdj_DoOne_RecentTasks() {
369 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
370 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
Jing Ji094c3ef2019-08-27 17:02:09 -0700[diff] [blame]371 doReturn(mock(WindowProcessController.class)).when(app).getWindowProcessController();
372 WindowProcessController wpc = app.getWindowProcessController();
373 doReturn(true).when(wpc).hasRecentTasks();
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]374 app.lastTopTime = SystemClock.uptimeMillis();
375 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
376 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
Jing Ji094c3ef2019-08-27 17:02:09 -0700[diff] [blame]377 doCallRealMethod().when(wpc).hasRecentTasks();
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]378
379 assertEquals(PROCESS_STATE_CACHED_RECENT, app.setProcState);
380 }
381
382 @SuppressWarnings("GuardedBy")
383 @Test
384 public void testUpdateOomAdj_DoOne_FgServiceLocation() {
385 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
386 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
387 app.setHasForegroundServices(true, ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION);
388 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
389 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
390
Hui Yu26969322019-08-21 14:56:35 -0700[diff] [blame]391 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]392 SCHED_GROUP_DEFAULT);
393 }
394
395 @SuppressWarnings("GuardedBy")
396 @Test
397 public void testUpdateOomAdj_DoOne_FgService() {
398 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
399 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
400 app.setHasForegroundServices(true, 0);
401 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
402 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
403
404 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
405 SCHED_GROUP_DEFAULT);
406 }
407
408 @SuppressWarnings("GuardedBy")
409 @Test
410 public void testUpdateOomAdj_DoOne_OverlayUi() {
411 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
412 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
413 app.setHasOverlayUi(true);
414 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
415 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
416
417 assertProcStates(app, PROCESS_STATE_IMPORTANT_FOREGROUND, PERCEPTIBLE_APP_ADJ,
418 SCHED_GROUP_DEFAULT);
419 }
420
421 @SuppressWarnings("GuardedBy")
422 @Test
423 public void testUpdateOomAdj_DoOne_PerceptibleRecent() {
424 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
425 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
426 app.setHasForegroundServices(true, 0);
427 app.lastTopTime = SystemClock.uptimeMillis();
428 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
429 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
430
431 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE,
432 PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ, SCHED_GROUP_DEFAULT);
433 }
434
435 @SuppressWarnings("GuardedBy")
436 @Test
437 public void testUpdateOomAdj_DoOne_Toast() {
438 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
439 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
440 app.forcingToImportant = new Object();
441 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
442 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
443
444 assertProcStates(app, PROCESS_STATE_TRANSIENT_BACKGROUND, PERCEPTIBLE_APP_ADJ,
445 SCHED_GROUP_DEFAULT);
446 }
447
448 @SuppressWarnings("GuardedBy")
449 @Test
450 public void testUpdateOomAdj_DoOne_HeavyWeight() {
451 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
452 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
453 doReturn(true).when(sService.mAtmInternal).isHeavyWeightProcess(any(
454 WindowProcessController.class));
455 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
456 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
457 doReturn(false).when(sService.mAtmInternal).isHeavyWeightProcess(any(
458 WindowProcessController.class));
459
460 assertProcStates(app, PROCESS_STATE_HEAVY_WEIGHT, HEAVY_WEIGHT_APP_ADJ,
461 SCHED_GROUP_BACKGROUND);
462 }
463
464 @SuppressWarnings("GuardedBy")
465 @Test
466 public void testUpdateOomAdj_DoOne_HomeApp() {
467 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
468 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
469 doReturn(mock(WindowProcessController.class)).when(app).getWindowProcessController();
470 WindowProcessController wpc = app.getWindowProcessController();
471 doReturn(true).when(wpc).isHomeProcess();
472 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
473 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
474
475 assertProcStates(app, PROCESS_STATE_HOME, HOME_APP_ADJ, SCHED_GROUP_BACKGROUND);
476 }
477
478 @SuppressWarnings("GuardedBy")
479 @Test
480 public void testUpdateOomAdj_DoOne_PreviousApp() {
481 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
482 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
483 doReturn(mock(WindowProcessController.class)).when(app).getWindowProcessController();
484 WindowProcessController wpc = app.getWindowProcessController();
485 doReturn(true).when(wpc).isPreviousProcess();
Jing Ji094c3ef2019-08-27 17:02:09 -0700[diff] [blame]486 doReturn(true).when(wpc).hasActivities();
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]487 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
488 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
489
490 assertProcStates(app, PROCESS_STATE_LAST_ACTIVITY, PREVIOUS_APP_ADJ,
491 SCHED_GROUP_BACKGROUND);
492 }
493
494 @SuppressWarnings("GuardedBy")
495 @Test
496 public void testUpdateOomAdj_DoOne_Backup() {
497 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
498 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
499 BackupRecord backupTarget = new BackupRecord(null, 0, 0);
500 backupTarget.app = app;
501 doReturn(backupTarget).when(sService.mBackupTargets).get(anyInt());
502 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
503 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
504 doReturn(null).when(sService.mBackupTargets).get(anyInt());
505
506 assertProcStates(app, PROCESS_STATE_TRANSIENT_BACKGROUND, BACKUP_APP_ADJ,
507 SCHED_GROUP_BACKGROUND);
508 }
509
510 @SuppressWarnings("GuardedBy")
511 @Test
512 public void testUpdateOomAdj_DoOne_ClientActivities() {
513 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
514 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
515 doReturn(true).when(app).hasClientActivities();
516 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
517 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
518
519 assertEquals(PROCESS_STATE_CACHED_ACTIVITY_CLIENT, app.setProcState);
520 }
521
522 @SuppressWarnings("GuardedBy")
523 @Test
524 public void testUpdateOomAdj_DoOne_TreatLikeActivity() {
525 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
526 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
527 app.treatLikeActivity = true;
528 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
529 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
530
531 assertEquals(PROCESS_STATE_CACHED_ACTIVITY, app.setProcState);
532 }
533
534 @SuppressWarnings("GuardedBy")
535 @Test
536 public void testUpdateOomAdj_DoOne_ServiceB() {
537 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
538 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
539 app.serviceb = true;
540 ServiceRecord s = mock(ServiceRecord.class);
541 doReturn(new ArrayMap<IBinder, ArrayList<ConnectionRecord>>()).when(s).getConnections();
542 s.startRequested = true;
543 s.lastActivity = SystemClock.uptimeMillis();
Darryl L Johnsond02044c2020-04-17 11:52:50 -0700[diff] [blame^]544 app.startService(s);
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]545 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
546 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
547
548 assertProcStates(app, PROCESS_STATE_SERVICE, SERVICE_B_ADJ, SCHED_GROUP_BACKGROUND);
549 }
550
551 @SuppressWarnings("GuardedBy")
552 @Test
553 public void testUpdateOomAdj_DoOne_MaxAdj() {
554 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
555 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
556 app.maxAdj = PERCEPTIBLE_LOW_APP_ADJ;
557 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
558 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
559
560 assertProcStates(app, PROCESS_STATE_CACHED_EMPTY, PERCEPTIBLE_LOW_APP_ADJ,
561 SCHED_GROUP_DEFAULT);
562 }
563
564 @SuppressWarnings("GuardedBy")
565 @Test
Jing Ji057f4cb2019-11-01 13:23:11 -0700[diff] [blame]566 public void testUpdateOomAdj_DoOne_NonCachedToCached() {
567 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
568 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
Darryl L Johnson72aac102020-01-15 15:16:36 -0800[diff] [blame]569 app.setCached(false);
Jing Ji057f4cb2019-11-01 13:23:11 -0700[diff] [blame]570 app.setCurRawAdj(SERVICE_ADJ);
571 doReturn(null).when(sService).getTopAppLocked();
572 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
573 sService.mOomAdjuster.updateOomAdjLocked(app, OomAdjuster.OOM_ADJ_REASON_NONE);
574
575 assertTrue(ProcessList.CACHED_APP_MIN_ADJ <= app.setAdj);
576 assertTrue(ProcessList.CACHED_APP_MAX_ADJ >= app.setAdj);
577 }
578
579 @SuppressWarnings("GuardedBy")
580 @Test
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]581 public void testUpdateOomAdj_DoOne_Service_Started() {
582 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
583 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
584 ServiceRecord s = mock(ServiceRecord.class);
585 doReturn(new ArrayMap<IBinder, ArrayList<ConnectionRecord>>()).when(s).getConnections();
586 s.startRequested = true;
587 s.lastActivity = SystemClock.uptimeMillis();
Darryl L Johnsond02044c2020-04-17 11:52:50 -0700[diff] [blame^]588 app.startService(s);
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]589 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
590 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
591
592 assertProcStates(app, PROCESS_STATE_SERVICE, SERVICE_ADJ, SCHED_GROUP_BACKGROUND);
593 }
594
595 @SuppressWarnings("GuardedBy")
596 @Test
597 public void testUpdateOomAdj_DoOne_Service_Started_WaivePriority() {
598 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
599 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
600 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
601 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
602 ServiceRecord s = bindService(app, client, null, Context.BIND_WAIVE_PRIORITY,
603 mock(IBinder.class));
604 s.startRequested = true;
605 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
606 doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
607 doReturn(client).when(sService).getTopAppLocked();
608 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
609 doReturn(null).when(sService).getTopAppLocked();
610
611 assertProcStates(app, PROCESS_STATE_SERVICE, UNKNOWN_ADJ, SCHED_GROUP_BACKGROUND);
612 }
613
614 @SuppressWarnings("GuardedBy")
615 @Test
616 public void testUpdateOomAdj_DoOne_Service_Started_WaivePriority_TreatLikeActivity() {
617 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
618 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
619 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
620 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
621 bindService(app, client, null, Context.BIND_WAIVE_PRIORITY
622 | Context.BIND_TREAT_LIKE_ACTIVITY, mock(IBinder.class));
623 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
624 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
625
626 assertEquals(PROCESS_STATE_CACHED_ACTIVITY, app.setProcState);
627 }
628
629 @SuppressWarnings("GuardedBy")
630 @Test
631 public void testUpdateOomAdj_DoOne_Service_Started_WaivePriority_AdjustWithActivity() {
632 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
633 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
634 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
635 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
636 IBinder binder = mock(IBinder.class);
637 ServiceRecord s = bindService(app, client, null, Context.BIND_WAIVE_PRIORITY
638 | Context.BIND_ADJUST_WITH_ACTIVITY | Context.BIND_IMPORTANT, binder);
639 ConnectionRecord cr = s.getConnections().get(binder).get(0);
640 setFieldValue(ConnectionRecord.class, cr, "activity",
641 mock(ActivityServiceConnectionsHolder.class));
642 doReturn(true).when(cr.activity).isActivityVisible();
643 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
644 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
645
646 assertEquals(FOREGROUND_APP_ADJ, app.setAdj);
647 assertEquals(SCHED_GROUP_TOP_APP_BOUND, app.setSchedGroup);
648 }
649
650 @SuppressWarnings("GuardedBy")
651 @Test
652 public void testUpdateOomAdj_DoOne_Service_Self() {
653 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
654 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
655 bindService(app, app, null, 0, mock(IBinder.class));
656 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
657 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
658
659 assertProcStates(app, PROCESS_STATE_CACHED_EMPTY, UNKNOWN_ADJ, SCHED_GROUP_BACKGROUND);
660 }
661
662 @SuppressWarnings("GuardedBy")
663 @Test
664 public void testUpdateOomAdj_DoOne_Service_CachedActivity() {
665 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
666 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
667 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
668 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
669 client.treatLikeActivity = true;
670 bindService(app, client, null, 0, mock(IBinder.class));
671 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
672 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
673
674 assertEquals(PROCESS_STATE_CACHED_EMPTY, app.setProcState);
675 }
676
677 @SuppressWarnings("GuardedBy")
678 @Test
679 public void testUpdateOomAdj_DoOne_Service_AllowOomManagement() {
680 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
681 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
682 doReturn(mock(WindowProcessController.class)).when(app).getWindowProcessController();
683 WindowProcessController wpc = app.getWindowProcessController();
684 doReturn(false).when(wpc).isHomeProcess();
685 doReturn(true).when(wpc).isPreviousProcess();
Jing Ji094c3ef2019-08-27 17:02:09 -0700[diff] [blame]686 doReturn(true).when(wpc).hasActivities();
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]687 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
688 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
689 bindService(app, client, null, Context.BIND_ALLOW_OOM_MANAGEMENT, mock(IBinder.class));
690 doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
691 doReturn(client).when(sService).getTopAppLocked();
692 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
693 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
694 doReturn(null).when(sService).getTopAppLocked();
695
696 assertEquals(PREVIOUS_APP_ADJ, app.setAdj);
697 }
698
699 @SuppressWarnings("GuardedBy")
700 @Test
701 public void testUpdateOomAdj_DoOne_Service_BoundByPersistentService() {
702 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
703 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
704 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
705 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
706 bindService(app, client, null, Context.BIND_FOREGROUND_SERVICE, mock(IBinder.class));
707 client.maxAdj = PERSISTENT_PROC_ADJ;
708 client.setHasTopUi(true);
709 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
710 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
711
712 assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, VISIBLE_APP_ADJ,
713 SCHED_GROUP_DEFAULT);
714 }
715
716 @SuppressWarnings("GuardedBy")
717 @Test
718 public void testUpdateOomAdj_DoOne_Service_Bound_ImportantFg() {
719 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
720 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
721 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
722 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
723 bindService(app, client, null, Context.BIND_IMPORTANT, mock(IBinder.class));
724 client.executingServices.add(mock(ServiceRecord.class));
725 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
726 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
727
728 assertEquals(FOREGROUND_APP_ADJ, app.setAdj);
729 }
730
731 @SuppressWarnings("GuardedBy")
732 @Test
733 public void testUpdateOomAdj_DoOne_Service_BoundByTop() {
734 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
735 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
736 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
737 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
738 bindService(app, client, null, 0, mock(IBinder.class));
739 doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
740 doReturn(client).when(sService).getTopAppLocked();
741 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
742 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
743 doReturn(null).when(sService).getTopAppLocked();
744
745 assertProcStates(app, PROCESS_STATE_BOUND_TOP, VISIBLE_APP_ADJ, SCHED_GROUP_DEFAULT);
746 }
747
748 @SuppressWarnings("GuardedBy")
749 @Test
750 public void testUpdateOomAdj_DoOne_Service_BoundFgService() {
751 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
752 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
753 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
754 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
755 bindService(app, client, null, Context.BIND_FOREGROUND_SERVICE, mock(IBinder.class));
756 client.maxAdj = PERSISTENT_PROC_ADJ;
757 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
758 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
759
760 assertEquals(PROCESS_STATE_BOUND_FOREGROUND_SERVICE, app.setProcState);
761 }
762
763 @SuppressWarnings("GuardedBy")
764 @Test
765 public void testUpdateOomAdj_DoOne_Service_BoundNotForeground() {
766 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
767 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
768 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
769 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
770 bindService(app, client, null, Context.BIND_NOT_FOREGROUND, mock(IBinder.class));
771 client.maxAdj = PERSISTENT_PROC_ADJ;
772 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
773 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
774
775 assertEquals(PROCESS_STATE_TRANSIENT_BACKGROUND, app.setProcState);
776 }
777
778 @SuppressWarnings("GuardedBy")
779 @Test
780 public void testUpdateOomAdj_DoOne_Service_ImportantFgService() {
781 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
782 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
783 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
784 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
785 bindService(app, client, null, 0, mock(IBinder.class));
786 client.setHasForegroundServices(true, 0);
787 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
788 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
789
790 assertEquals(PROCESS_STATE_FOREGROUND_SERVICE, app.setProcState);
791 }
792
793 @SuppressWarnings("GuardedBy")
794 @Test
795 public void testUpdateOomAdj_DoOne_Service_BoundByBackup_AboveClient() {
796 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
797 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
798 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
799 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
800 bindService(app, client, null, Context.BIND_ABOVE_CLIENT, mock(IBinder.class));
801 BackupRecord backupTarget = new BackupRecord(null, 0, 0);
802 backupTarget.app = client;
803 doReturn(backupTarget).when(sService.mBackupTargets).get(anyInt());
804 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
805 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
806 doReturn(null).when(sService.mBackupTargets).get(anyInt());
807
808 assertEquals(BACKUP_APP_ADJ, app.setAdj);
809
810 client.maxAdj = PERSISTENT_PROC_ADJ;
811 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
812
813 assertEquals(PERSISTENT_SERVICE_ADJ, app.setAdj);
814 }
815
816 @SuppressWarnings("GuardedBy")
817 @Test
818 public void testUpdateOomAdj_DoOne_Service_NotPerceptible() {
819 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
820 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
821 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
822 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
823 bindService(app, client, null, Context.BIND_NOT_PERCEPTIBLE, mock(IBinder.class));
824 client.runningRemoteAnimation = true;
825 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
826 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
827
828 assertEquals(PERCEPTIBLE_LOW_APP_ADJ, app.setAdj);
829 }
830
831 @SuppressWarnings("GuardedBy")
832 @Test
833 public void testUpdateOomAdj_DoOne_Service_NotVisible() {
834 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
835 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
836 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
837 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
838 bindService(app, client, null, Context.BIND_NOT_VISIBLE, mock(IBinder.class));
839 client.runningRemoteAnimation = true;
840 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
841 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
842
843 assertEquals(PERCEPTIBLE_APP_ADJ, app.setAdj);
844 }
845
846 @SuppressWarnings("GuardedBy")
847 @Test
848 public void testUpdateOomAdj_DoOne_Service_Perceptible() {
849 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
850 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
851 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
852 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
853 bindService(app, client, null, 0, mock(IBinder.class));
854 client.setHasOverlayUi(true);
855 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
856 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
857
858 assertEquals(PERCEPTIBLE_APP_ADJ, app.setAdj);
859 }
860
861 @SuppressWarnings("GuardedBy")
862 @Test
863 public void testUpdateOomAdj_DoOne_Service_Other() {
864 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
865 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
866 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
867 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
868 bindService(app, client, null, 0, mock(IBinder.class));
869 client.runningRemoteAnimation = true;
870 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
871 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
872
873 assertEquals(VISIBLE_APP_ADJ, app.setAdj);
874 }
875
876 @SuppressWarnings("GuardedBy")
877 @Test
878 public void testUpdateOomAdj_DoOne_Service_Bind_ImportantBg() {
879 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
880 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
881 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
882 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
883 bindService(app, client, null, Context.BIND_IMPORTANT_BACKGROUND, mock(IBinder.class));
884 client.setHasOverlayUi(true);
885 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
886 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
887
888 assertEquals(PROCESS_STATE_IMPORTANT_BACKGROUND, app.setProcState);
889 }
890
891 @SuppressWarnings("GuardedBy")
892 @Test
893 public void testUpdateOomAdj_DoOne_Provider_Self() {
894 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
895 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
896 bindProvider(app, app, null, null, false);
897 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
898
899 assertProcStates(app, PROCESS_STATE_CACHED_EMPTY, UNKNOWN_ADJ, SCHED_GROUP_BACKGROUND);
900 }
901
902 @SuppressWarnings("GuardedBy")
903 @Test
904 public void testUpdateOomAdj_DoOne_Provider_Cached_Activity() {
905 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
906 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
907 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
908 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
909 bindProvider(app, client, null, null, false);
910 client.treatLikeActivity = true;
911 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
912 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
913
914 assertProcStates(app, PROCESS_STATE_CACHED_EMPTY, UNKNOWN_ADJ, SCHED_GROUP_BACKGROUND);
915 }
916
917 @SuppressWarnings("GuardedBy")
918 @Test
919 public void testUpdateOomAdj_DoOne_Provider_TopApp() {
920 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
921 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
922 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
923 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
924 bindProvider(app, client, null, null, false);
925 doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
926 doReturn(client).when(sService).getTopAppLocked();
927 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
928 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
929 doReturn(null).when(sService).getTopAppLocked();
930
931 assertProcStates(app, PROCESS_STATE_BOUND_TOP, FOREGROUND_APP_ADJ, SCHED_GROUP_DEFAULT);
932 }
933
934 @SuppressWarnings("GuardedBy")
935 @Test
936 public void testUpdateOomAdj_DoOne_Provider_FgService() {
937 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
938 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
939 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
940 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
941 client.setHasForegroundServices(true, 0);
942 bindProvider(app, client, null, null, false);
943 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
944 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
945
946 assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
947 SCHED_GROUP_DEFAULT);
948 }
949
950 @SuppressWarnings("GuardedBy")
951 @Test
952 public void testUpdateOomAdj_DoOne_Provider_ExternalProcessHandles() {
953 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
954 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
955 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
956 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
957 bindProvider(app, client, null, null, true);
958 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
959 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
960
961 assertProcStates(app, PROCESS_STATE_IMPORTANT_FOREGROUND, FOREGROUND_APP_ADJ,
962 SCHED_GROUP_DEFAULT);
963 }
964
965 @SuppressWarnings("GuardedBy")
966 @Test
967 public void testUpdateOomAdj_DoOne_Provider_Retention() {
968 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
969 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
970 app.lastProviderTime = SystemClock.uptimeMillis();
971 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
972 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
973
974 assertProcStates(app, PROCESS_STATE_LAST_ACTIVITY, PREVIOUS_APP_ADJ,
975 SCHED_GROUP_BACKGROUND);
976 }
977
978 @SuppressWarnings("GuardedBy")
979 @Test
980 public void testUpdateOomAdj_DoOne_Service_Chain_BoundByTop() {
981 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
982 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
983 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
984 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
985 bindService(app, client, null, 0, mock(IBinder.class));
986 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
987 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
988 bindService(client, client2, null, 0, mock(IBinder.class));
989 doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
990 doReturn(client2).when(sService).getTopAppLocked();
991 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
992 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
993 doReturn(null).when(sService).getTopAppLocked();
994
Hui Yu814cedf2020-03-11 15:31:46 -0700[diff] [blame]995 assertProcStates(app, PROCESS_STATE_BOUND_TOP, VISIBLE_APP_ADJ,
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]996 SCHED_GROUP_DEFAULT);
997 }
998
999 @SuppressWarnings("GuardedBy")
1000 @Test
1001 public void testUpdateOomAdj_DoOne_Service_BoundByFgService_Branch() {
1002 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1003 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1004 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1005 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1006 bindService(app, client, null, 0, mock(IBinder.class));
1007 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1008 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1009 bindService(app, client2, null, 0, mock(IBinder.class));
1010 client2.setHasForegroundServices(true, 0);
1011 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1012 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
1013
1014 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1015 SCHED_GROUP_DEFAULT);
1016 }
1017
1018 @SuppressWarnings("GuardedBy")
1019 @Test
1020 public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService() {
1021 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1022 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1023 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1024 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1025 bindService(app, client, null, 0, mock(IBinder.class));
1026 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1027 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1028 bindService(client, client2, null, 0, mock(IBinder.class));
1029 client2.setHasForegroundServices(true, 0);
1030 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1031 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
1032
1033 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1034 SCHED_GROUP_DEFAULT);
1035 }
1036
1037 @SuppressWarnings("GuardedBy")
1038 @Test
1039 public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle() {
1040 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1041 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1042 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1043 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1044 bindService(app, client, null, 0, mock(IBinder.class));
1045 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1046 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1047 bindService(client, client2, null, 0, mock(IBinder.class));
1048 client2.setHasForegroundServices(true, 0);
1049 bindService(client2, app, null, 0, mock(IBinder.class));
Jing Ji619d6442019-11-21 18:26:40 -0800[diff] [blame]1050 ArrayList<ProcessRecord> lru = sService.mProcessList.mLruProcesses;
1051 lru.clear();
1052 lru.add(app);
1053 lru.add(client);
1054 lru.add(client2);
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]1055 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
Jing Ji619d6442019-11-21 18:26:40 -0800[diff] [blame]1056 sService.mOomAdjuster.updateOomAdjLocked(app, true, OomAdjuster.OOM_ADJ_REASON_NONE);
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]1057
1058 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1059 SCHED_GROUP_DEFAULT);
Jing Ji619d6442019-11-21 18:26:40 -0800[diff] [blame]1060 assertProcStates(client, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1061 SCHED_GROUP_DEFAULT);
1062 assertProcStates(client2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1063 SCHED_GROUP_DEFAULT);
1064
1065 client2.setHasForegroundServices(false, 0);
1066 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1067 sService.mOomAdjuster.updateOomAdjLocked(client2, true, OomAdjuster.OOM_ADJ_REASON_NONE);
1068
1069 assertEquals(PROCESS_STATE_CACHED_EMPTY, client2.setProcState);
1070 assertEquals(PROCESS_STATE_CACHED_EMPTY, client.setProcState);
1071 assertEquals(PROCESS_STATE_CACHED_EMPTY, app.setProcState);
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]1072 }
1073
1074 @SuppressWarnings("GuardedBy")
1075 @Test
Jing Ji6708c412019-12-04 22:33:30 -0800[diff] [blame]1076 public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_2() {
1077 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1078 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1079 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1080 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1081 bindService(app, client, null, 0, mock(IBinder.class));
1082 bindService(client, app, null, 0, mock(IBinder.class));
1083 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1084 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1085 bindService(client2, client, null, 0, mock(IBinder.class));
1086 client.setHasForegroundServices(true, 0);
1087 ArrayList<ProcessRecord> lru = sService.mProcessList.mLruProcesses;
1088 lru.clear();
1089 lru.add(app);
1090 lru.add(client);
1091 lru.add(client2);
1092 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1093 sService.mOomAdjuster.updateOomAdjLocked(app, true, OomAdjuster.OOM_ADJ_REASON_NONE);
1094
1095 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1096 SCHED_GROUP_DEFAULT);
1097 assertProcStates(client, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1098 SCHED_GROUP_DEFAULT);
1099 assertProcStates(client2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1100 SCHED_GROUP_DEFAULT);
1101 }
1102
1103 @SuppressWarnings("GuardedBy")
1104 @Test
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]1105 public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_Branch() {
1106 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1107 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1108 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1109 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1110 bindService(app, client, null, 0, mock(IBinder.class));
1111 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1112 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1113 bindService(client, client2, null, 0, mock(IBinder.class));
1114 client2.setHasForegroundServices(true, 0);
1115 bindService(client2, app, null, 0, mock(IBinder.class));
1116 ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1117 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1118 client3.forcingToImportant = new Object();
1119 bindService(app, client3, null, 0, mock(IBinder.class));
1120 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1121 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
1122
1123 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1124 SCHED_GROUP_DEFAULT);
1125 }
1126
1127 @SuppressWarnings("GuardedBy")
1128 @Test
1129 public void testUpdateOomAdj_DoOne_Service_Chain_Perceptible_Cycle_Branch() {
1130 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1131 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1132 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1133 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1134 bindService(app, client, null, 0, mock(IBinder.class));
1135 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1136 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1137 bindService(client, client2, null, 0, mock(IBinder.class));
1138 bindService(client2, app, null, 0, mock(IBinder.class));
1139 doReturn(mock(WindowProcessController.class)).when(client2).getWindowProcessController();
1140 WindowProcessController wpc = client2.getWindowProcessController();
1141 doReturn(true).when(wpc).isHomeProcess();
1142 ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1143 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1144 client3.forcingToImportant = new Object();
1145 bindService(app, client3, null, 0, mock(IBinder.class));
1146 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1147 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
1148
1149 assertProcStates(app, PROCESS_STATE_TRANSIENT_BACKGROUND, PERCEPTIBLE_APP_ADJ,
1150 SCHED_GROUP_DEFAULT);
1151 }
1152
1153 @SuppressWarnings("GuardedBy")
1154 @Test
1155 public void testUpdateOomAdj_DoOne_Service_Chain_Perceptible_Cycle_2() {
1156 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1157 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1158 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1159 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1160 bindService(app, client, null, 0, mock(IBinder.class));
1161 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1162 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1163 bindService(client, client2, null, 0, mock(IBinder.class));
1164 bindService(client2, app, null, 0, mock(IBinder.class));
1165 doReturn(mock(WindowProcessController.class)).when(client2).getWindowProcessController();
1166 WindowProcessController wpc = client2.getWindowProcessController();
1167 doReturn(true).when(wpc).isHomeProcess();
1168 ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1169 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1170 ProcessRecord client4 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
1171 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
1172 client4.forcingToImportant = new Object();
1173 bindService(app, client4, null, 0, mock(IBinder.class));
1174 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1175 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
1176
1177 assertProcStates(app, PROCESS_STATE_TRANSIENT_BACKGROUND, PERCEPTIBLE_APP_ADJ,
1178 SCHED_GROUP_DEFAULT);
1179 }
1180
1181 @SuppressWarnings("GuardedBy")
1182 @Test
1183 public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_Branch_2() {
1184 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1185 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1186 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1187 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1188 bindService(app, client, null, 0, mock(IBinder.class));
1189 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1190 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1191 bindService(client, client2, null, 0, mock(IBinder.class));
1192 bindService(client2, app, null, 0, mock(IBinder.class));
1193 doReturn(mock(WindowProcessController.class)).when(client2).getWindowProcessController();
1194 WindowProcessController wpc = client2.getWindowProcessController();
1195 doReturn(true).when(wpc).isHomeProcess();
1196 ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1197 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1198 client3.forcingToImportant = new Object();
1199 bindService(app, client3, null, 0, mock(IBinder.class));
1200 ProcessRecord client4 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
1201 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
1202 client4.setHasForegroundServices(true, 0);
1203 bindService(app, client4, null, 0, mock(IBinder.class));
1204 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1205 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
1206
1207 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1208 SCHED_GROUP_DEFAULT);
1209 }
1210
1211 @SuppressWarnings("GuardedBy")
1212 @Test
1213 public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Branch_3() {
1214 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1215 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1216 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1217 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1218 doReturn(mock(WindowProcessController.class)).when(client).getWindowProcessController();
1219 WindowProcessController wpc = client.getWindowProcessController();
1220 doReturn(true).when(wpc).isHomeProcess();
1221 bindService(app, client, null, 0, mock(IBinder.class));
1222 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1223 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1224 bindService(app, client2, null, 0, mock(IBinder.class));
1225 client2.setHasForegroundServices(true, 0);
1226 ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1227 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1228 client3.forcingToImportant = new Object();
1229 bindService(app, client3, null, 0, mock(IBinder.class));
1230 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1231 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
1232
1233 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1234 SCHED_GROUP_DEFAULT);
1235 }
1236
1237 @SuppressWarnings("GuardedBy")
1238 @Test
1239 public void testUpdateOomAdj_DoOne_Service_Provider() {
1240 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1241 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1242 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1243 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1244 bindService(app, client, null, 0, mock(IBinder.class));
1245 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1246 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1247 bindProvider(client, client2, null, null, false);
1248 client2.setHasForegroundServices(true, 0);
1249 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1250 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
1251
1252 assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1253 SCHED_GROUP_DEFAULT);
1254 }
1255
1256 @SuppressWarnings("GuardedBy")
1257 @Test
1258 public void testUpdateOomAdj_DoOne_Service_Provider_Cycle() {
1259 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1260 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1261 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1262 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1263 bindService(app, client, null, 0, mock(IBinder.class));
1264 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1265 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1266 bindProvider(client, client2, null, null, false);
1267 client2.setHasForegroundServices(true, 0);
1268 bindService(client2, app, null, 0, mock(IBinder.class));
1269 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1270 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
1271
1272 assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1273 SCHED_GROUP_DEFAULT);
1274 }
1275
1276 @SuppressWarnings("GuardedBy")
1277 @Test
1278 public void testUpdateOomAdj_DoOne_Provider_Chain_BoundByFgService() {
1279 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1280 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1281 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1282 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1283 bindProvider(app, client, null, null, false);
1284 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1285 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1286 bindProvider(client, client2, null, null, false);
1287 client2.setHasForegroundServices(true, 0);
1288 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1289 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
1290
1291 assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1292 SCHED_GROUP_DEFAULT);
1293 }
1294
1295 @SuppressWarnings("GuardedBy")
1296 @Test
1297 public void testUpdateOomAdj_DoOne_Provider_Chain_BoundByFgService_Cycle() {
1298 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1299 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1300 ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1301 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1302 bindProvider(app, client, null, null, false);
1303 ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1304 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1305 bindProvider(client, client2, null, null, false);
1306 client2.setHasForegroundServices(true, 0);
1307 bindProvider(client2, app, null, null, false);
1308 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1309 sService.mOomAdjuster.updateOomAdjLocked(app, false, OomAdjuster.OOM_ADJ_REASON_NONE);
1310
1311 assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1312 SCHED_GROUP_DEFAULT);
1313 }
1314
1315 @SuppressWarnings("GuardedBy")
1316 @Test
1317 public void testUpdateOomAdj_DoAll_Unbound() {
1318 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1319 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1320 app.forcingToImportant = new Object();
1321 ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1322 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1323 app2.setHasForegroundServices(true, 0);
1324 ArrayList<ProcessRecord> lru = sService.mProcessList.mLruProcesses;
1325 lru.clear();
1326 lru.add(app);
1327 lru.add(app2);
1328 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1329 sService.mOomAdjuster.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
1330 lru.clear();
1331
1332 assertProcStates(app, PROCESS_STATE_TRANSIENT_BACKGROUND, PERCEPTIBLE_APP_ADJ,
1333 SCHED_GROUP_DEFAULT);
1334 assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1335 SCHED_GROUP_DEFAULT);
1336 }
1337
1338 @SuppressWarnings("GuardedBy")
1339 @Test
1340 public void testUpdateOomAdj_DoAll_BoundFgService() {
1341 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1342 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1343 app.forcingToImportant = new Object();
1344 ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1345 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1346 app2.setHasForegroundServices(true, 0);
1347 bindService(app, app2, null, 0, mock(IBinder.class));
1348 ArrayList<ProcessRecord> lru = sService.mProcessList.mLruProcesses;
1349 lru.clear();
1350 lru.add(app);
1351 lru.add(app2);
1352 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1353 sService.mOomAdjuster.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
1354 lru.clear();
1355
1356 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1357 SCHED_GROUP_DEFAULT);
1358 assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1359 SCHED_GROUP_DEFAULT);
1360 }
1361
1362 @SuppressWarnings("GuardedBy")
1363 @Test
1364 public void testUpdateOomAdj_DoAll_BoundFgService_Cycle() {
1365 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1366 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1367 ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1368 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1369 bindService(app, app2, null, 0, mock(IBinder.class));
1370 ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1371 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1372 bindService(app2, app3, null, 0, mock(IBinder.class));
1373 app3.setHasForegroundServices(true, 0);
1374 bindService(app3, app, null, 0, mock(IBinder.class));
1375 ArrayList<ProcessRecord> lru = sService.mProcessList.mLruProcesses;
1376 lru.clear();
1377 lru.add(app);
1378 lru.add(app2);
1379 lru.add(app3);
1380 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1381 sService.mOomAdjuster.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
1382 lru.clear();
1383
1384 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1385 SCHED_GROUP_DEFAULT);
1386 assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1387 SCHED_GROUP_DEFAULT);
1388 assertProcStates(app3, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1389 SCHED_GROUP_DEFAULT);
1390 }
1391
1392 @SuppressWarnings("GuardedBy")
1393 @Test
1394 public void testUpdateOomAdj_DoAll_BoundFgService_Cycle_Branch_2() {
1395 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1396 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1397 ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1398 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1399 ServiceRecord s = bindService(app, app2, null, 0, mock(IBinder.class));
1400 ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1401 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1402 bindService(app2, app3, null, 0, mock(IBinder.class));
1403 bindService(app3, app, null, 0, mock(IBinder.class));
1404 doReturn(mock(WindowProcessController.class)).when(app3).getWindowProcessController();
1405 WindowProcessController wpc = app3.getWindowProcessController();
1406 doReturn(true).when(wpc).isHomeProcess();
1407 ProcessRecord app4 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1408 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1409 app4.setHasOverlayUi(true);
1410 bindService(app, app4, s, 0, mock(IBinder.class));
1411 ProcessRecord app5 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
1412 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
1413 app5.setHasForegroundServices(true, 0);
1414 bindService(app, app5, s, 0, mock(IBinder.class));
1415 ArrayList<ProcessRecord> lru = sService.mProcessList.mLruProcesses;
1416 lru.clear();
1417 lru.add(app);
1418 lru.add(app2);
1419 lru.add(app3);
1420 lru.add(app4);
1421 lru.add(app5);
1422 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1423 sService.mOomAdjuster.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
1424 lru.clear();
1425
1426 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1427 SCHED_GROUP_DEFAULT);
1428 assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1429 SCHED_GROUP_DEFAULT);
1430 assertProcStates(app3, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1431 SCHED_GROUP_DEFAULT);
1432 assertProcStates(app4, PROCESS_STATE_IMPORTANT_FOREGROUND, PERCEPTIBLE_APP_ADJ,
1433 SCHED_GROUP_DEFAULT);
1434 assertProcStates(app5, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1435 SCHED_GROUP_DEFAULT);
1436 }
1437
1438 @SuppressWarnings("GuardedBy")
1439 @Test
1440 public void testUpdateOomAdj_DoAll_BoundFgService_Cycle_Branch_3() {
1441 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1442 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1443 ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1444 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1445 ServiceRecord s = bindService(app, app2, null, 0, mock(IBinder.class));
1446 ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1447 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1448 bindService(app2, app3, null, 0, mock(IBinder.class));
1449 bindService(app3, app, null, 0, mock(IBinder.class));
1450 doReturn(mock(WindowProcessController.class)).when(app3).getWindowProcessController();
1451 WindowProcessController wpc = app3.getWindowProcessController();
1452 doReturn(true).when(wpc).isHomeProcess();
1453 ProcessRecord app4 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1454 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1455 app4.setHasOverlayUi(true);
1456 bindService(app, app4, s, 0, mock(IBinder.class));
1457 ProcessRecord app5 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
1458 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
1459 app5.setHasForegroundServices(true, 0);
1460 bindService(app, app5, s, 0, mock(IBinder.class));
1461 ArrayList<ProcessRecord> lru = sService.mProcessList.mLruProcesses;
1462 lru.clear();
1463 lru.add(app5);
1464 lru.add(app4);
1465 lru.add(app3);
1466 lru.add(app2);
1467 lru.add(app);
1468 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1469 sService.mOomAdjuster.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
1470 lru.clear();
1471
1472 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1473 SCHED_GROUP_DEFAULT);
1474 assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1475 SCHED_GROUP_DEFAULT);
1476 assertProcStates(app3, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1477 SCHED_GROUP_DEFAULT);
1478 assertProcStates(app4, PROCESS_STATE_IMPORTANT_FOREGROUND, PERCEPTIBLE_APP_ADJ,
1479 SCHED_GROUP_DEFAULT);
1480 assertProcStates(app5, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1481 SCHED_GROUP_DEFAULT);
1482 }
1483
1484 @SuppressWarnings("GuardedBy")
1485 @Test
1486 public void testUpdateOomAdj_DoAll_BoundFgService_Cycle_Branch_4() {
1487 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1488 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1489 ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1490 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1491 ServiceRecord s = bindService(app, app2, null, 0, mock(IBinder.class));
1492 ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1493 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1494 bindService(app2, app3, null, 0, mock(IBinder.class));
1495 bindService(app3, app, null, 0, mock(IBinder.class));
1496 doReturn(mock(WindowProcessController.class)).when(app3).getWindowProcessController();
1497 WindowProcessController wpc = app3.getWindowProcessController();
1498 doReturn(true).when(wpc).isHomeProcess();
1499 ProcessRecord app4 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1500 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1501 app4.setHasOverlayUi(true);
1502 bindService(app, app4, s, 0, mock(IBinder.class));
1503 ProcessRecord app5 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
1504 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
1505 app5.setHasForegroundServices(true, 0);
1506 bindService(app, app5, s, 0, mock(IBinder.class));
1507 ArrayList<ProcessRecord> lru = sService.mProcessList.mLruProcesses;
1508 lru.clear();
1509 lru.add(app3);
1510 lru.add(app4);
1511 lru.add(app2);
1512 lru.add(app);
1513 lru.add(app5);
1514 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1515 sService.mOomAdjuster.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
1516 lru.clear();
1517
1518 assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1519 SCHED_GROUP_DEFAULT);
1520 assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1521 SCHED_GROUP_DEFAULT);
1522 assertProcStates(app3, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1523 SCHED_GROUP_DEFAULT);
1524 assertProcStates(app4, PROCESS_STATE_IMPORTANT_FOREGROUND, PERCEPTIBLE_APP_ADJ,
1525 SCHED_GROUP_DEFAULT);
1526 assertProcStates(app5, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1527 SCHED_GROUP_DEFAULT);
1528 }
1529
1530 @SuppressWarnings("GuardedBy")
1531 @Test
1532 public void testUpdateOomAdj_DoAll_Provider_Cycle_Branch_2() {
1533 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1534 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1535 ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1536 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1537 ContentProviderRecord cr = bindProvider(app, app2, null, null, false);
1538 ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1539 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1540 bindProvider(app2, app3, null, null, false);
1541 bindProvider(app3, app, null, null, false);
1542 doReturn(mock(WindowProcessController.class)).when(app3).getWindowProcessController();
1543 WindowProcessController wpc = app3.getWindowProcessController();
1544 doReturn(true).when(wpc).isHomeProcess();
1545 ProcessRecord app4 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1546 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1547 app4.setHasOverlayUi(true);
1548 bindProvider(app, app4, cr, null, false);
1549 ProcessRecord app5 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
1550 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
1551 app5.setHasForegroundServices(true, 0);
1552 bindProvider(app, app5, cr, null, false);
1553 ArrayList<ProcessRecord> lru = sService.mProcessList.mLruProcesses;
1554 lru.clear();
1555 lru.add(app);
1556 lru.add(app2);
1557 lru.add(app3);
1558 lru.add(app4);
1559 lru.add(app5);
1560 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1561 sService.mOomAdjuster.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
1562 lru.clear();
1563
1564 assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1565 SCHED_GROUP_DEFAULT);
1566 assertProcStates(app2, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1567 SCHED_GROUP_DEFAULT);
1568 assertProcStates(app3, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1569 SCHED_GROUP_DEFAULT);
1570 assertProcStates(app4, PROCESS_STATE_IMPORTANT_FOREGROUND, PERCEPTIBLE_APP_ADJ,
1571 SCHED_GROUP_DEFAULT);
1572 assertProcStates(app5, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1573 SCHED_GROUP_DEFAULT);
1574 }
1575
Jing Ji327ba182019-08-08 14:10:39 -0700[diff] [blame]1576 @SuppressWarnings("GuardedBy")
1577 @Test
1578 public void testUpdateOomAdj_DoAll_ServiceB() {
1579 ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1580 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1581 ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1582 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1583 long now = SystemClock.uptimeMillis();
1584 ServiceRecord s = bindService(app, app2, null, 0, mock(IBinder.class));
1585 s.startRequested = true;
1586 s.lastActivity = now;
1587 s = bindService(app2, app, null, 0, mock(IBinder.class));
1588 s.startRequested = true;
1589 s.lastActivity = now;
1590 ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1591 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1592 s = mock(ServiceRecord.class);
1593 s.app = app3;
1594 setFieldValue(ServiceRecord.class, s, "connections",
1595 new ArrayMap<IBinder, ArrayList<ConnectionRecord>>());
Darryl L Johnsond02044c2020-04-17 11:52:50 -0700[diff] [blame^]1596 app3.startService(s);
Jing Ji327ba182019-08-08 14:10:39 -0700[diff] [blame]1597 doCallRealMethod().when(s).getConnections();
1598 s.startRequested = true;
1599 s.lastActivity = now;
1600 ArrayList<ProcessRecord> lru = sService.mProcessList.mLruProcesses;
1601 lru.clear();
1602 lru.add(app3);
1603 lru.add(app2);
1604 lru.add(app);
1605 sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1606 sService.mOomAdjuster.mNumServiceProcs = 3;
1607 sService.mOomAdjuster.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
1608 lru.clear();
1609
1610 assertEquals(SERVICE_B_ADJ, app3.setAdj);
1611 assertEquals(SERVICE_ADJ, app2.setAdj);
1612 assertEquals(SERVICE_ADJ, app.setAdj);
1613 }
1614
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]1615 private ProcessRecord makeDefaultProcessRecord(int pid, int uid, String processName,
1616 String packageName, boolean hasShownUi) {
1617 long now = SystemClock.uptimeMillis();
1618 return makeProcessRecord(sService, pid, uid, processName,
1619 packageName, 12345, Build.VERSION_CODES.CUR_DEVELOPMENT,
1620 now, now, now, 12345, UNKNOWN_ADJ, UNKNOWN_ADJ,
1621 UNKNOWN_ADJ, CACHED_APP_MAX_ADJ,
1622 SCHED_GROUP_DEFAULT, SCHED_GROUP_DEFAULT,
1623 PROCESS_STATE_NONEXISTENT, PROCESS_STATE_NONEXISTENT,
1624 PROCESS_STATE_NONEXISTENT, PROCESS_STATE_NONEXISTENT,
1625 0, 0, false, false, false, ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE,
1626 false, false, false, hasShownUi, false, false, false, false, false, false, null,
1627 0, 0, 0, true, 0, null, false);
1628 }
1629
1630 private ProcessRecord makeProcessRecord(ActivityManagerService service, int pid, int uid,
1631 String processName, String packageName, long versionCode, int targetSdkVersion,
1632 long lastActivityTime, long lastPssTime, long nextPssTime, long lastPss, int maxAdj,
1633 int setRawAdj, int curAdj, int setAdj, int curSchedGroup, int setSchedGroup,
1634 int curProcState, int repProcState, int curRawProcState, int setProcState,
1635 int connectionGroup, int connectionImportance, boolean serviceb,
1636 boolean hasClientActivities, boolean hasForegroundServices, int fgServiceTypes,
1637 boolean hasForegroundActivities, boolean repForegroundActivities, boolean systemNoUi,
1638 boolean hasShownUi, boolean hasTopUi, boolean hasOverlayUi,
1639 boolean runningRemoteAnimation, boolean hasAboveClient, boolean treatLikeActivity,
1640 boolean killedByAm, Object forcingToImportant, int numOfCurReceivers,
1641 long lastProviderTime, long lastTopTime, boolean cached, int numOfExecutingServices,
1642 String isolatedEntryPoint, boolean execServicesFg) {
1643 ApplicationInfo ai = spy(new ApplicationInfo());
1644 ai.uid = uid;
1645 ai.packageName = packageName;
1646 ai.longVersionCode = versionCode;
1647 ai.targetSdkVersion = targetSdkVersion;
1648 ProcessRecord app = new ProcessRecord(service, ai, processName, uid);
1649 app.thread = mock(IApplicationThread.class);
1650 app.lastActivityTime = lastActivityTime;
1651 app.lastPssTime = lastPssTime;
1652 app.nextPssTime = nextPssTime;
1653 app.lastPss = lastPss;
1654 app.maxAdj = maxAdj;
1655 app.setRawAdj = setRawAdj;
1656 app.curAdj = curAdj;
1657 app.setAdj = setAdj;
1658 app.setCurrentSchedulingGroup(curSchedGroup);
1659 app.setSchedGroup = setSchedGroup;
1660 app.setCurProcState(curProcState);
1661 app.setReportedProcState(repProcState);
1662 app.setCurRawProcState(curRawProcState);
1663 app.setProcState = setProcState;
1664 app.connectionGroup = connectionGroup;
1665 app.connectionImportance = connectionImportance;
1666 app.serviceb = serviceb;
1667 app.setHasClientActivities(hasClientActivities);
1668 app.setHasForegroundServices(hasForegroundServices, fgServiceTypes);
1669 app.setHasClientActivities(hasForegroundActivities);
1670 app.repForegroundActivities = repForegroundActivities;
1671 app.systemNoUi = systemNoUi;
1672 app.hasShownUi = hasShownUi;
1673 app.setHasTopUi(hasTopUi);
1674 app.setHasOverlayUi(hasOverlayUi);
1675 app.runningRemoteAnimation = runningRemoteAnimation;
1676 app.hasAboveClient = hasAboveClient;
1677 app.treatLikeActivity = treatLikeActivity;
1678 app.killedByAm = killedByAm;
1679 app.forcingToImportant = forcingToImportant;
1680 for (int i = 0; i < numOfCurReceivers; i++) {
1681 app.curReceivers.add(mock(BroadcastRecord.class));
1682 }
1683 app.lastProviderTime = lastProviderTime;
1684 app.lastTopTime = lastTopTime;
Darryl L Johnson72aac102020-01-15 15:16:36 -0800[diff] [blame]1685 app.setCached(cached);
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]1686 for (int i = 0; i < numOfExecutingServices; i++) {
1687 app.executingServices.add(mock(ServiceRecord.class));
1688 }
1689 app.isolatedEntryPoint = isolatedEntryPoint;
1690 app.execServicesFg = execServicesFg;
1691 return app;
1692 }
1693
1694 private ServiceRecord bindService(ProcessRecord service, ProcessRecord client,
1695 ServiceRecord record, int bindFlags, IBinder binder) {
1696 if (record == null) {
1697 record = mock(ServiceRecord.class);
1698 record.app = service;
1699 setFieldValue(ServiceRecord.class, record, "connections",
1700 new ArrayMap<IBinder, ArrayList<ConnectionRecord>>());
Darryl L Johnsond02044c2020-04-17 11:52:50 -0700[diff] [blame^]1701 service.startService(record);
Jing Ji05dfd912019-08-02 13:44:15 -0700[diff] [blame]1702 doCallRealMethod().when(record).getConnections();
1703 }
1704 AppBindRecord binding = new AppBindRecord(record, null, client);
1705 ConnectionRecord cr = spy(new ConnectionRecord(binding,
1706 mock(ActivityServiceConnectionsHolder.class),
1707 mock(IServiceConnection.class), bindFlags,
1708 0, null, client.uid, client.processName, client.info.packageName));
1709 doCallRealMethod().when(record).addConnection(any(IBinder.class),
1710 any(ConnectionRecord.class));
1711 record.addConnection(binder, cr);
1712 client.connections.add(cr);
1713 binding.connections.add(cr);
1714 doNothing().when(cr).trackProcState(anyInt(), anyInt(), anyLong());
1715 return record;
1716 }
1717
1718 private ContentProviderRecord bindProvider(ProcessRecord publisher, ProcessRecord client,
1719 ContentProviderRecord record, String name, boolean hasExternalProviders) {
1720 if (record == null) {
1721 record = mock(ContentProviderRecord.class);
1722 publisher.pubProviders.put(name, record);
1723 record.proc = publisher;
1724 setFieldValue(ContentProviderRecord.class, record, "connections",
1725 new ArrayList<ContentProviderConnection>());
1726 doReturn(hasExternalProviders).when(record).hasExternalProcessHandles();
1727 }
1728 ContentProviderConnection conn = spy(new ContentProviderConnection(record, client,
1729 client.info.packageName));
1730 record.connections.add(conn);
1731 client.conProviders.add(conn);
1732 return record;
1733 }
1734
1735 private void assertProcStates(ProcessRecord app, int expectedProcState, int expectedAdj,
1736 int expectedSchedGroup) {
1737 assertEquals(expectedProcState, app.setProcState);
1738 assertEquals(expectedAdj, app.setAdj);
1739 assertEquals(expectedSchedGroup, app.setSchedGroup);
1740 }
1741}