Merge "Fix concurrency limits." into tm-dev

apex/jobscheduler/service/java/com/android/server/job/JobConcurrencyManager.java

@@ -84,10 +84,12 @@ class JobConcurrencyManager {
     private static final String KEY_SCREEN_OFF_ADJUSTMENT_DELAY_MS =
             CONFIG_KEY_PREFIX_CONCURRENCY + "screen_off_adjustment_delay_ms";
     private static final long DEFAULT_SCREEN_OFF_ADJUSTMENT_DELAY_MS = 30_000;
-    private static final String KEY_PKG_CONCURRENCY_LIMIT_EJ =
+    @VisibleForTesting
+    static final String KEY_PKG_CONCURRENCY_LIMIT_EJ =
             CONFIG_KEY_PREFIX_CONCURRENCY + "pkg_concurrency_limit_ej";
     private static final int DEFAULT_PKG_CONCURRENCY_LIMIT_EJ = 3;
-    private static final String KEY_PKG_CONCURRENCY_LIMIT_REGULAR =
+    @VisibleForTesting
+    static final String KEY_PKG_CONCURRENCY_LIMIT_REGULAR =
             CONFIG_KEY_PREFIX_CONCURRENCY + "pkg_concurrency_limit_regular";
     private static final int DEFAULT_PKG_CONCURRENCY_LIMIT_REGULAR = MAX_JOB_CONTEXTS_COUNT / 2;
 
@@ -299,13 +301,13 @@ class JobConcurrencyManager {
      * The maximum number of expedited jobs a single userId-package can have running simultaneously.
      * TOP apps are not limited.
      */
-    private long mPkgConcurrencyLimitEj = DEFAULT_PKG_CONCURRENCY_LIMIT_EJ;
+    private int mPkgConcurrencyLimitEj = DEFAULT_PKG_CONCURRENCY_LIMIT_EJ;
 
     /**
      * The maximum number of regular jobs a single userId-package can have running simultaneously.
      * TOP apps are not limited.
      */
-    private long mPkgConcurrencyLimitRegular = DEFAULT_PKG_CONCURRENCY_LIMIT_REGULAR;
+    private int mPkgConcurrencyLimitRegular = DEFAULT_PKG_CONCURRENCY_LIMIT_REGULAR;
 
     /** Current memory trim level. */
     private int mLastMemoryTrimLevel;
@@ -568,7 +570,7 @@ class JobConcurrencyManager {
             Slog.d(TAG, printPendingQueueLocked());
         }
 
-        final PendingJobQueue pendingJobQueue = mService.mPendingJobQueue;
+        final PendingJobQueue pendingJobQueue = mService.getPendingJobQueue();
         final List<JobServiceContext> activeServices = mActiveServices;
 
         // To avoid GC churn, we recycle the arrays.
@@ -916,7 +918,8 @@ class JobConcurrencyManager {
     }
 
     @GuardedBy("mLock")
-    private boolean isPkgConcurrencyLimitedLocked(@NonNull JobStatus jobStatus) {
+    @VisibleForTesting
+    boolean isPkgConcurrencyLimitedLocked(@NonNull JobStatus jobStatus) {
         if (jobStatus.lastEvaluatedBias >= JobInfo.BIAS_TOP_APP) {
             // Don't restrict top apps' concurrency. The work type limits will make sure
             // background jobs have slots to run if the system has resources.
@@ -924,7 +927,7 @@ class JobConcurrencyManager {
         }
         // Use < instead of <= as that gives us a little wiggle room in case a new job comes
         // along very shortly.
-        if (mService.mPendingJobQueue.size() + mRunningJobs.size()
+        if (mService.getPendingJobQueue().size() + mRunningJobs.size()
                 < mWorkTypeConfig.getMaxTotal()) {
             // Don't artificially limit a single package if we don't even have enough jobs to use
             // the maximum number of slots. We'll preempt the job later if we need the slot.
@@ -937,10 +940,10 @@ class JobConcurrencyManager {
             return false;
         }
         if (jobStatus.shouldTreatAsExpeditedJob()) {
-            return packageStats.numRunningEj + packageStats.numStagedEj < mPkgConcurrencyLimitEj;
+            return packageStats.numRunningEj + packageStats.numStagedEj >= mPkgConcurrencyLimitEj;
         } else {
             return packageStats.numRunningRegular + packageStats.numStagedRegular
-                    < mPkgConcurrencyLimitRegular;
+                    >= mPkgConcurrencyLimitRegular;
         }
     }
 
@@ -981,7 +984,7 @@ class JobConcurrencyManager {
                         jobStatus.getSourceUserId(), jobStatus.getSourcePackageName(),
                         packageStats);
             }
-            if (mService.mPendingJobQueue.remove(jobStatus)) {
+            if (mService.getPendingJobQueue().remove(jobStatus)) {
                 mService.mJobPackageTracker.noteNonpending(jobStatus);
             }
         } finally {
@@ -1008,7 +1011,7 @@ class JobConcurrencyManager {
             }
         }
 
-        final PendingJobQueue pendingJobQueue = mService.mPendingJobQueue;
+        final PendingJobQueue pendingJobQueue = mService.getPendingJobQueue();
         if (worker.getPreferredUid() != JobServiceContext.NO_PREFERRED_UID) {
             updateCounterConfigLocked();
             // Preemption case needs special care.
@@ -1176,7 +1179,7 @@ class JobConcurrencyManager {
             return "too many jobs running";
         }
 
-        final PendingJobQueue pendingJobQueue = mService.mPendingJobQueue;
+        final PendingJobQueue pendingJobQueue = mService.getPendingJobQueue();
         final int numPending = pendingJobQueue.size();
         if (numPending == 0) {
             // All quiet. We can let this job run to completion.
@@ -1259,7 +1262,7 @@ class JobConcurrencyManager {
     @GuardedBy("mLock")
     private String printPendingQueueLocked() {
         StringBuilder s = new StringBuilder("Pending queue: ");
-        PendingJobQueue pendingJobQueue = mService.mPendingJobQueue;
+        PendingJobQueue pendingJobQueue = mService.getPendingJobQueue();
         JobStatus js;
         pendingJobQueue.resetIterator();
         while ((js = pendingJobQueue.next()) != null) {
@@ -1523,8 +1526,8 @@ class JobConcurrencyManager {
 
     @VisibleForTesting
     static class WorkTypeConfig {
-        private static final String KEY_PREFIX_MAX_TOTAL =
+        @VisibleForTesting
-                CONFIG_KEY_PREFIX_CONCURRENCY + "max_total_";
+        static final String KEY_PREFIX_MAX_TOTAL = CONFIG_KEY_PREFIX_CONCURRENCY + "max_total_";
         private static final String KEY_PREFIX_MAX_TOP = CONFIG_KEY_PREFIX_CONCURRENCY + "max_top_";
         private static final String KEY_PREFIX_MAX_FGS = CONFIG_KEY_PREFIX_CONCURRENCY + "max_fgs_";
         private static final String KEY_PREFIX_MAX_EJ = CONFIG_KEY_PREFIX_CONCURRENCY + "max_ej_";
@@ -2025,7 +2028,8 @@ class JobConcurrencyManager {
         }
     }
 
-    private static class PackageStats {
+    @VisibleForTesting
+    static class PackageStats {
         public int userId;
         public String packageName;
         public int numRunningEj;
@@ -2095,4 +2099,32 @@ class JobConcurrencyManager {
             newWorkType = WORK_TYPE_NONE;
         }
     }
+
+    // TESTING HELPERS
+
+    @VisibleForTesting
+    void addRunningJobForTesting(@NonNull JobStatus job) {
+        mRunningJobs.add(job);
+        final PackageStats packageStats =
+                getPackageStatsForTesting(job.getSourceUserId(), job.getSourcePackageName());
+        packageStats.adjustRunningCount(true, job.shouldTreatAsExpeditedJob());
+    }
+
+    @VisibleForTesting
+    int getPackageConcurrencyLimitEj() {
+        return mPkgConcurrencyLimitEj;
+    }
+
+    int getPackageConcurrencyLimitRegular() {
+        return mPkgConcurrencyLimitRegular;
+    }
+
+    /** Gets the {@link PackageStats} object for the app and saves it for testing use. */
+    @NonNull
+    @VisibleForTesting
+    PackageStats getPackageStatsForTesting(int userId, @NonNull String packageName) {
+        final PackageStats packageStats = getPkgStatsLocked(userId, packageName);
+        mActivePkgStats.add(userId, packageName, packageStats);
+        return packageStats;
+    }
 }

apex/jobscheduler/service/java/com/android/server/job/JobSchedulerService.java

@@ -286,7 +286,7 @@ public class JobSchedulerService extends com.android.server.SystemService
      * Queue of pending jobs. The JobServiceContext class will receive jobs from this list
      * when ready to execute them.
      */
-    final PendingJobQueue mPendingJobQueue = new PendingJobQueue();
+    private final PendingJobQueue mPendingJobQueue = new PendingJobQueue();
 
     int[] mStartedUsers = EmptyArray.INT;
 
@@ -1027,6 +1027,11 @@ public class JobSchedulerService extends com.android.server.SystemService
         return mConstants;
     }
 
+    @NonNull
+    PendingJobQueue getPendingJobQueue() {
+        return mPendingJobQueue;
+    }
+
     @NonNull
     public WorkSource deriveWorkSource(int sourceUid, @Nullable String sourcePackageName) {
         if (WorkSource.isChainedBatteryAttributionEnabled(getContext())) {

services/tests/mockingservicestests/src/com/android/server/job/JobConcurrencyManagerTest.java

@@ -16,6 +16,10 @@
 
 package com.android.server.job;
 
+import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn;
+import static com.android.server.job.JobConcurrencyManager.KEY_PKG_CONCURRENCY_LIMIT_EJ;
+import static com.android.server.job.JobConcurrencyManager.KEY_PKG_CONCURRENCY_LIMIT_REGULAR;
+
 import static junit.framework.Assert.assertFalse;
 import static junit.framework.Assert.assertTrue;
 
@@ -30,6 +34,7 @@ import android.content.Context;
 import android.content.pm.UserInfo;
 import android.content.res.Resources;
 import android.os.UserHandle;
+import android.provider.DeviceConfig;
 
 import androidx.test.filters.SmallTest;
 import androidx.test.runner.AndroidJUnit4;
@@ -37,9 +42,11 @@ import androidx.test.runner.AndroidJUnit4;
 import com.android.internal.R;
 import com.android.server.LocalServices;
 import com.android.server.job.JobConcurrencyManager.GracePeriodObserver;
+import com.android.server.job.JobConcurrencyManager.WorkTypeConfig;
 import com.android.server.job.controllers.JobStatus;
 import com.android.server.pm.UserManagerInternal;
 
+import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
@@ -54,9 +61,12 @@ public final class JobConcurrencyManagerTest {
     private UserManagerInternal mUserManagerInternal;
     private ActivityManagerInternal mActivityManagerInternal;
     private int mNextUserId;
+    private int mDefaultUserId;
     private GracePeriodObserver mGracePeriodObserver;
     private Context mContext;
     private Resources mResources;
+    private PendingJobQueue mPendingJobQueue;
+    private DeviceConfig.Properties.Builder mConfigBuilder;
 
     @BeforeClass
     public static void setUpOnce() {
@@ -80,14 +90,224 @@ public final class JobConcurrencyManagerTest {
                 R.bool.config_jobSchedulerRestrictBackgroundUser);
         when(mContext.getResources()).thenReturn(mResources);
         doReturn(mContext).when(jobSchedulerService).getTestableContext();
+        mConfigBuilder = new DeviceConfig.Properties.Builder(DeviceConfig.NAMESPACE_JOB_SCHEDULER);
+        mPendingJobQueue = new PendingJobQueue();
+        doReturn(mPendingJobQueue).when(jobSchedulerService).getPendingJobQueue();
         mJobConcurrencyManager = new JobConcurrencyManager(jobSchedulerService);
         mGracePeriodObserver = mock(GracePeriodObserver.class);
         mUserManagerInternal = LocalServices.getService(UserManagerInternal.class);
         mActivityManagerInternal = LocalServices.getService(ActivityManagerInternal.class);
+        mDefaultUserId = mNextUserId;
+        createCurrentUser(true);
         mNextUserId = 10;
         mJobConcurrencyManager.mGracePeriodObserver = mGracePeriodObserver;
     }
 
+    @After
+    public void tearDown() throws Exception {
+        resetConfig();
+    }
+
+    @Test
+    public void testIsPkgConcurrencyLimited_top() {
+        final JobStatus topJob = createJob(mDefaultUserId * UserHandle.PER_USER_RANGE, 0);
+        topJob.lastEvaluatedBias = JobInfo.BIAS_TOP_APP;
+
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(topJob));
+
+        // Pending jobs shouldn't affect TOP job's status.
+        for (int i = 1; i <= JobSchedulerService.MAX_JOB_CONTEXTS_COUNT; ++i) {
+            final JobStatus job = createJob(mDefaultUserId * UserHandle.PER_USER_RANGE + i);
+            mPendingJobQueue.add(job);
+        }
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(topJob));
+
+        // Already running jobs shouldn't affect TOP job's status.
+        for (int i = 1; i <= JobSchedulerService.MAX_JOB_CONTEXTS_COUNT; ++i) {
+            final JobStatus job = createJob(mDefaultUserId * UserHandle.PER_USER_RANGE, i);
+            mJobConcurrencyManager.addRunningJobForTesting(job);
+        }
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(topJob));
+
+        // Currently running or staged jobs shouldn't affect TOP job's status.
+        final JobConcurrencyManager.PackageStats packageStats =
+                mJobConcurrencyManager.getPackageStatsForTesting(
+                        topJob.getSourceUserId(), topJob.getSourcePackageName());
+        packageStats.numStagedEj = mJobConcurrencyManager.getPackageConcurrencyLimitEj();
+        packageStats.numStagedRegular = mJobConcurrencyManager.getPackageConcurrencyLimitRegular();
+        packageStats.numRunningEj = 0;
+        packageStats.numRunningRegular = 0;
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(topJob));
+
+        packageStats.numStagedEj = 0;
+        packageStats.numStagedRegular = 0;
+        packageStats.numRunningEj = mJobConcurrencyManager.getPackageConcurrencyLimitEj();
+        packageStats.numRunningRegular = mJobConcurrencyManager.getPackageConcurrencyLimitRegular();
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(topJob));
+    }
+
+    @Test
+    public void testIsPkgConcurrencyLimited_belowTotalLimit() throws Exception {
+        final JobStatus testJob = createJob(mDefaultUserId * UserHandle.PER_USER_RANGE);
+
+        setConcurrencyConfig(8);
+
+        // Pending jobs below limit shouldn't affect job's status.
+        for (int i = 0; i < 5; ++i) {
+            final JobStatus job = createJob(mDefaultUserId * UserHandle.PER_USER_RANGE + i);
+            mPendingJobQueue.add(job);
+        }
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testJob));
+
+        mPendingJobQueue.clear();
+
+        // Already running jobs below limit shouldn't affect job's status.
+        for (int i = 0; i < 4; ++i) {
+            final JobStatus job = createJob(mDefaultUserId * UserHandle.PER_USER_RANGE + i);
+            mJobConcurrencyManager.addRunningJobForTesting(job);
+        }
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testJob));
+
+        // Mix of pending + running.
+        for (int i = 4; i < 8; ++i) {
+            final JobStatus job = createJob(mDefaultUserId * UserHandle.PER_USER_RANGE + i);
+            mPendingJobQueue.add(job);
+        }
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testJob));
+    }
+
+    @Test
+    public void testIsPkgConcurrencyLimited() throws Exception {
+        final JobStatus testReg = createJob(mDefaultUserId * UserHandle.PER_USER_RANGE, 0);
+        final JobStatus testEj = createJob(mDefaultUserId * UserHandle.PER_USER_RANGE, 1);
+        spyOn(testEj);
+        doReturn(true).when(testEj).shouldTreatAsExpeditedJob();
+
+        setConcurrencyConfig(JobSchedulerService.MAX_JOB_CONTEXTS_COUNT);
+
+        for (int i = 0; i < JobSchedulerService.MAX_JOB_CONTEXTS_COUNT; ++i) {
+            final JobStatus job = createJob(mDefaultUserId * UserHandle.PER_USER_RANGE + i, i + 1);
+            mPendingJobQueue.add(job);
+        }
+
+        // App has no running jobs, so shouldn't be limited.
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        // Already running jobs shouldn't affect TOP job's status.
+        final JobConcurrencyManager.PackageStats packageStats =
+                mJobConcurrencyManager.getPackageStatsForTesting(
+                        testReg.getSourceUserId(), testReg.getSourcePackageName());
+
+        // Only running counts
+        packageStats.numStagedEj = 0;
+        packageStats.numStagedRegular = 0;
+        packageStats.numRunningEj = 4;
+        packageStats.numRunningRegular = 4;
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 8);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 8);
+        updateDeviceConfig();
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 8);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 4);
+        updateDeviceConfig();
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 8);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 3);
+        updateDeviceConfig();
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 4);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 8);
+        updateDeviceConfig();
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 3);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 8);
+        updateDeviceConfig();
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        // Only staged counts
+        packageStats.numStagedEj = 4;
+        packageStats.numStagedRegular = 4;
+        packageStats.numRunningEj = 0;
+        packageStats.numRunningRegular = 0;
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 8);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 8);
+        updateDeviceConfig();
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 8);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 4);
+        updateDeviceConfig();
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 8);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 3);
+        updateDeviceConfig();
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 4);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 8);
+        updateDeviceConfig();
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 3);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 8);
+        updateDeviceConfig();
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        // Running + staged counts
+        packageStats.numStagedEj = 2;
+        packageStats.numStagedRegular = 1;
+        packageStats.numRunningEj = 2;
+        packageStats.numRunningRegular = 3;
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 8);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 8);
+        updateDeviceConfig();
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 8);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 4);
+        updateDeviceConfig();
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 8);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 3);
+        updateDeviceConfig();
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 4);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 8);
+        updateDeviceConfig();
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_EJ, 3);
+        mConfigBuilder.setInt(KEY_PKG_CONCURRENCY_LIMIT_REGULAR, 8);
+        updateDeviceConfig();
+        assertTrue(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testEj));
+        assertFalse(mJobConcurrencyManager.isPkgConcurrencyLimitedLocked(testReg));
+    }
+
     @Test
     public void testShouldRunAsFgUserJob_currentUser() {
         assertTrue(mJobConcurrencyManager.shouldRunAsFgUserJob(
@@ -179,10 +399,40 @@ public final class JobConcurrencyManagerTest {
     }
 
     private static JobStatus createJob(UserInfo userInfo) {
-        JobStatus jobStatus = JobStatus.createFromJobInfo(
+        return createJob(userInfo.id * UserHandle.PER_USER_RANGE);
-                new JobInfo.Builder(1, new ComponentName("foo", "bar")).build(),
+    }
-                userInfo.id * UserHandle.PER_USER_RANGE,
+
-                null, userInfo.id, "JobConcurrencyManagerTest");
+    private static JobStatus createJob(int uid) {
-        return jobStatus;
+        return createJob(uid, 1);
+    }
+
+    private static JobStatus createJob(int uid, int jobId) {
+        return JobStatus.createFromJobInfo(
+                new JobInfo.Builder(jobId, new ComponentName("foo", "bar")).build(), uid,
+                null, UserHandle.getUserId(uid), "JobConcurrencyManagerTest");
+    }
+
+    private void setConcurrencyConfig(int total) throws Exception {
+        // Set the values for all memory states so we don't have to worry about memory on the device
+        // during testing.
+        final String[] identifiers = {
+                "screen_on_normal", "screen_on_moderate", "screen_on_low", "screen_on_critical",
+                "screen_off_normal", "screen_off_moderate", "screen_off_low", "screen_off_critical"
+        };
+        for (String identifier : identifiers) {
+            mConfigBuilder
+                    .setInt(WorkTypeConfig.KEY_PREFIX_MAX_TOTAL + identifier, total);
+        }
+        updateDeviceConfig();
+    }
+
+    private void updateDeviceConfig() throws Exception {
+        DeviceConfig.setProperties(mConfigBuilder.build());
+        mJobConcurrencyManager.updateConfigLocked();
+    }
+
+    private void resetConfig() throws Exception {
+        mConfigBuilder = new DeviceConfig.Properties.Builder(DeviceConfig.NAMESPACE_JOB_SCHEDULER);
+        updateDeviceConfig();
     }
 }

services/tests/mockingservicestests/src/com/android/server/job/JobSchedulerServiceTest.java

@@ -757,7 +757,7 @@ public class JobSchedulerServiceTest {
         job.setStandbyBucket(RARE_INDEX);
 
         // Not enough RARE jobs to run.
-        mService.mPendingJobQueue.clear();
+        mService.getPendingJobQueue().clear();
         maybeQueueFunctor.reset();
         for (int i = 0; i < mService.mConstants.MIN_READY_NON_ACTIVE_JOBS_COUNT / 2; ++i) {
             maybeQueueFunctor.accept(job);
@@ -766,10 +766,10 @@ public class JobSchedulerServiceTest {
             assertEquals(sElapsedRealtimeClock.millis(), job.getFirstForceBatchedTimeElapsed());
         }
         maybeQueueFunctor.postProcessLocked();
-        assertEquals(0, mService.mPendingJobQueue.size());
+        assertEquals(0, mService.getPendingJobQueue().size());
 
         // Enough RARE jobs to run.
-        mService.mPendingJobQueue.clear();
+        mService.getPendingJobQueue().clear();
         maybeQueueFunctor.reset();
         for (int i = 0; i < mService.mConstants.MIN_READY_NON_ACTIVE_JOBS_COUNT; ++i) {
             maybeQueueFunctor.accept(job);
@@ -778,10 +778,10 @@ public class JobSchedulerServiceTest {
             assertEquals(sElapsedRealtimeClock.millis(), job.getFirstForceBatchedTimeElapsed());
         }
         maybeQueueFunctor.postProcessLocked();
-        assertEquals(5, mService.mPendingJobQueue.size());
+        assertEquals(5, mService.getPendingJobQueue().size());
 
         // Not enough RARE jobs to run, but a non-batched job saves the day.
-        mService.mPendingJobQueue.clear();
+        mService.getPendingJobQueue().clear();
         maybeQueueFunctor.reset();
         JobStatus activeJob = createJobStatus(
                 "testRareJobBatching",
@@ -795,10 +795,10 @@ public class JobSchedulerServiceTest {
         }
         maybeQueueFunctor.accept(activeJob);
         maybeQueueFunctor.postProcessLocked();
-        assertEquals(3, mService.mPendingJobQueue.size());
+        assertEquals(3, mService.getPendingJobQueue().size());
 
         // Not enough RARE jobs to run, but an old RARE job saves the day.
-        mService.mPendingJobQueue.clear();
+        mService.getPendingJobQueue().clear();
         maybeQueueFunctor.reset();
         JobStatus oldRareJob = createJobStatus("testRareJobBatching", createJobInfo());
         oldRareJob.setStandbyBucket(RARE_INDEX);
@@ -814,7 +814,7 @@ public class JobSchedulerServiceTest {
         maybeQueueFunctor.accept(oldRareJob);
         assertEquals(oldBatchTime, oldRareJob.getFirstForceBatchedTimeElapsed());
         maybeQueueFunctor.postProcessLocked();
-        assertEquals(3, mService.mPendingJobQueue.size());
+        assertEquals(3, mService.getPendingJobQueue().size());
     }
 
     /** Tests that jobs scheduled by the app itself are counted towards scheduling limits. */