tests/instrumentation/src/com/android/managedprovisioning/ota/OtaControllerTest.java - platform/packages/apps/ManagedProvisioning - Git at Google

 /*
  * Copyright 2016, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.managedprovisioning.ota;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;

 import android.app.admin.DevicePolicyManager;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.content.pm.UserInfo;
 import android.os.UserHandle;
 import android.os.UserManager;
 import android.util.ArraySet;
 import android.util.Pair;

 import androidx.test.InstrumentationRegistry;
 import androidx.test.filters.SmallTest;

 import com.android.managedprovisioning.analytics.ProvisioningAnalyticsTracker;
 import com.android.managedprovisioning.task.AbstractProvisioningTask;
 import com.android.managedprovisioning.task.CrossProfileIntentFiltersSetter;
 import com.android.managedprovisioning.task.DeleteNonRequiredAppsTask;
 import com.android.managedprovisioning.task.DisableInstallShortcutListenersTask;
 import com.android.managedprovisioning.task.DisallowAddUserTask;
 import com.android.managedprovisioning.task.InstallExistingPackageTask;
 import com.android.managedprovisioning.task.MigrateSystemAppsSnapshotTask;

 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.function.IntFunction;

 /**
  * Unit tests for {@link OtaController}.
  */
 @SmallTest
 public class OtaControllerTest {
     private static final int DEVICE_OWNER_USER_ID = 12;
     private static final int MANAGED_PROFILE_USER_ID = 15;
     private static final int MANAGED_USER_USER_ID = 18;

     private static final String DUMMY_SYSTEM_IME_PACKAGE_NAME =
             "com.android.inputmethod.dummysystemime";

     private static final ComponentName ADMIN_COMPONENT = new ComponentName("com.test.admin",
             ".AdminReceiver");

     private static final IntFunction<ArraySet<String>> NO_MISSING_SYSTEM_IME_PROVIDER
             = userHandle -> new ArraySet<>();

     @Mock private Context mContext;
     @Mock private DevicePolicyManager mDevicePolicyManager;
     @Mock private PackageManager mPackageManager;
     @Mock private UserManager mUserManager;
     @Mock private CrossProfileIntentFiltersSetter mCrossProfileIntentFiltersSetter;
     @Mock private ProvisioningAnalyticsTracker mProvisioningAnalyticsTracker;

     private TaskExecutor mTaskExecutor;

     private List<Pair<Integer, AbstractProvisioningTask>> mTasks = new ArrayList<>();
     private List<UserInfo> mUsers = new ArrayList<>();
     private List<UserInfo> mProfiles = new ArrayList<>();

     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);

         when(mContext.getSystemService(Context.DEVICE_POLICY_SERVICE))
                 .thenReturn(mDevicePolicyManager);
         when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager);
         when(mContext.getPackageManager()).thenReturn(mPackageManager);
         when(mContext.getResources())
                 .thenReturn(InstrumentationRegistry.getTargetContext().getResources());

         when(mUserManager.getUsers()).thenReturn(mUsers);
         when(mUserManager.getProfiles(UserHandle.USER_SYSTEM)).thenReturn(mProfiles);

         mTaskExecutor = new FakeTaskExecutor();

         addSystemUser();
     }

     @Test
     public void testDeviceOwnerSystemUser() {
         OtaController controller = new OtaController(mContext, mTaskExecutor,
                 mCrossProfileIntentFiltersSetter, NO_MISSING_SYSTEM_IME_PROVIDER,
                 mProvisioningAnalyticsTracker);

         // GIVEN that there is a device owner on the system user
         setDeviceOwner(UserHandle.USER_SYSTEM, ADMIN_COMPONENT);

         // WHEN running the OtaController
         controller.run();

         // THEN the task list should contain these tasks.
         assertTaskList(
                 Pair.create(UserHandle.USER_SYSTEM, MigrateSystemAppsSnapshotTask.class),
                 Pair.create(UserHandle.USER_SYSTEM, DeleteNonRequiredAppsTask.class),
                 Pair.create(UserHandle.USER_SYSTEM, DisallowAddUserTask.class));

         // THEN cross profile intent filters setter should be invoked for system user
         verify(mCrossProfileIntentFiltersSetter).resetFilters(UserHandle.USER_SYSTEM);
     }

     @Test
     public void testDeviceOwnerSeparate() {
         OtaController controller = new OtaController(mContext, mTaskExecutor,
                 mCrossProfileIntentFiltersSetter, NO_MISSING_SYSTEM_IME_PROVIDER,
                 mProvisioningAnalyticsTracker);

         // GIVEN that there is a device owner on a non-system meat user
         addMeatUser(DEVICE_OWNER_USER_ID);
         setDeviceOwner(DEVICE_OWNER_USER_ID, ADMIN_COMPONENT);

         // WHEN running the OtaController
         controller.run();

         // THEN the task list should contain DeleteNonRequiredAppsTask and DisallowAddUserTask
         assertTaskList(
                 Pair.create(UserHandle.USER_SYSTEM, MigrateSystemAppsSnapshotTask.class),
                 Pair.create(DEVICE_OWNER_USER_ID, DeleteNonRequiredAppsTask.class),
                 Pair.create(DEVICE_OWNER_USER_ID, DisallowAddUserTask.class));

         // THEN cross profile intent filters setter should be invoked for both users
         verify(mCrossProfileIntentFiltersSetter).resetFilters(UserHandle.USER_SYSTEM);
         verify(mCrossProfileIntentFiltersSetter).resetFilters(DEVICE_OWNER_USER_ID);
     }

     @Test
     public void testManagedProfileWithoutMissingSystemIme() {
         OtaController controller = new OtaController(mContext, mTaskExecutor,
                 mCrossProfileIntentFiltersSetter, NO_MISSING_SYSTEM_IME_PROVIDER,
                 mProvisioningAnalyticsTracker);

         // GIVEN that there is a managed profile
         addManagedProfile(MANAGED_PROFILE_USER_ID, ADMIN_COMPONENT);

         // WHEN running the OtaController
         controller.run();

         // THEN the task list should contain these tasks.
         assertTaskList(
                 Pair.create(UserHandle.USER_SYSTEM, MigrateSystemAppsSnapshotTask.class),
                 Pair.create(MANAGED_PROFILE_USER_ID, InstallExistingPackageTask.class),
                 Pair.create(MANAGED_PROFILE_USER_ID, DisableInstallShortcutListenersTask.class),
                 Pair.create(MANAGED_PROFILE_USER_ID, DeleteNonRequiredAppsTask.class));

         // THEN the cross profile intent filters should be reset
         verify(mCrossProfileIntentFiltersSetter).resetFilters(UserHandle.USER_SYSTEM);
         verify(mCrossProfileIntentFiltersSetter, never()).resetFilters(MANAGED_PROFILE_USER_ID);

         // THEN the DISALLOW_WALLPAPER restriction should be set
         verify(mUserManager).setUserRestriction(UserManager.DISALLOW_WALLPAPER, true,
                 UserHandle.of(MANAGED_PROFILE_USER_ID));
     }

     @Test
     public void testManagedProfileWithMissingSystemIme() {
         IntFunction<ArraySet<String>> missingSystemImeProvider =
                 (IntFunction<ArraySet<String>>) mock(IntFunction.class);

         OtaController controller = new OtaController(mContext, mTaskExecutor,
                 mCrossProfileIntentFiltersSetter, missingSystemImeProvider,
                 mProvisioningAnalyticsTracker);

         // GIVEN that there is a managed profile
         addManagedProfile(MANAGED_PROFILE_USER_ID, ADMIN_COMPONENT);

         // GIVEN that the managed profile does not have DUMMY_SYSTEM_IME_PACKAGE_NAME.
         ArraySet<String> missingImes = new ArraySet<>();
         missingImes.add(DUMMY_SYSTEM_IME_PACKAGE_NAME);
         when(missingSystemImeProvider.apply(MANAGED_PROFILE_USER_ID)).thenReturn(missingImes);

         // WHEN running the OtaController
         controller.run();

         // THEN the task list should contain these tasks.
         assertTaskList(
                 Pair.create(UserHandle.USER_SYSTEM, MigrateSystemAppsSnapshotTask.class),
                 Pair.create(MANAGED_PROFILE_USER_ID, InstallExistingPackageTask.class),
                 Pair.create(MANAGED_PROFILE_USER_ID, InstallExistingPackageTask.class),
                 Pair.create(MANAGED_PROFILE_USER_ID, DisableInstallShortcutListenersTask.class),
                 Pair.create(MANAGED_PROFILE_USER_ID, DeleteNonRequiredAppsTask.class));

         // THEN the cross profile intent filters should be reset
         verify(mCrossProfileIntentFiltersSetter).resetFilters(UserHandle.USER_SYSTEM);
         verify(mCrossProfileIntentFiltersSetter, never()).resetFilters(MANAGED_PROFILE_USER_ID);

         // THEN the DISALLOW_WALLPAPER restriction should be set
         verify(mUserManager).setUserRestriction(UserManager.DISALLOW_WALLPAPER, true,
                 UserHandle.of(MANAGED_PROFILE_USER_ID));

         // THEN the DUMMY_SYSTEM_IME_PACKAGE_NAME should be installed.
         assertInstallExistingPackageTask(MANAGED_PROFILE_USER_ID, DUMMY_SYSTEM_IME_PACKAGE_NAME);
     }

     @Test
     public void testManagedUser() {
         OtaController controller = new OtaController(mContext, mTaskExecutor,
                 mCrossProfileIntentFiltersSetter, NO_MISSING_SYSTEM_IME_PROVIDER,
                 mProvisioningAnalyticsTracker);

         // GIVEN that there is a managed profile
         addManagedUser(MANAGED_USER_USER_ID, ADMIN_COMPONENT);

         // WHEN running the OtaController
         controller.run();

         // THEN the task list should contain these tasks.
         assertTaskList(
                 Pair.create(UserHandle.USER_SYSTEM, MigrateSystemAppsSnapshotTask.class),
                 Pair.create(MANAGED_USER_USER_ID, DeleteNonRequiredAppsTask.class));
     }

     private class FakeTaskExecutor extends TaskExecutor {

         public FakeTaskExecutor() {
             super();
         }

         @Override
         public synchronized void execute(int userId, AbstractProvisioningTask task) {
             mTasks.add(Pair.create(userId, task));
         }
     }

     private void addMeatUser(int userId) {
         UserInfo ui = new UserInfo(userId, null, 0);
         mUsers.add(ui);
         when(mUserManager.getProfiles(userId)).thenReturn(Collections.singletonList(ui));
     }

     private void setDeviceOwner(int userId, ComponentName admin) {
         when(mDevicePolicyManager.getDeviceOwnerUserId()).thenReturn(userId);
         when(mDevicePolicyManager.getDeviceOwnerComponentOnAnyUser()).thenReturn(admin);
     }

     private void addManagedProfile(int userId, ComponentName admin) {
         UserInfo ui = new UserInfo(userId, null, UserInfo.FLAG_MANAGED_PROFILE);
         mUsers.add(ui);
         when(mDevicePolicyManager.getProfileOwnerAsUser(userId)).thenReturn(admin);
         when(mUserManager.getProfiles(userId)).thenReturn(Collections.singletonList(ui));
         mProfiles.add(ui);
     }

     private void addManagedUser(int userId, ComponentName admin) {
         UserInfo ui = new UserInfo(userId, null, 0);
         mUsers.add(ui);
         when(mDevicePolicyManager.getProfileOwnerAsUser(userId)).thenReturn(admin);
     }

     private void addSystemUser() {
         UserInfo ui = new UserInfo(UserHandle.USER_SYSTEM, null, UserInfo.FLAG_PRIMARY);
         mUsers.add(ui);
         mProfiles.add(ui);
     }

     private void assertTaskList(Pair<Integer, Class>... tasks) {
         assertEquals(tasks.length, mTasks.size());

         for (Pair<Integer, Class> task : tasks) {
             assertTaskListContains(task.first, task.second);
         }
     }

     private void assertTaskListContains(Integer userId, Class taskClass) {
         for (Pair<Integer, AbstractProvisioningTask> task : mTasks) {
             if (userId == task.first && taskClass.isInstance(task.second)) {
                 return;
             }
         }
         fail("Task for class " + taskClass + " and userId " + userId + " not executed");
     }

     private void assertInstallExistingPackageTask(int userId, String packageName) {
         for (Pair<Integer, AbstractProvisioningTask> task : mTasks) {
             if (userId != task.first || !InstallExistingPackageTask.class.isInstance(task.second)) {
                 continue;
             }
             InstallExistingPackageTask installExistingPackageTask =
                     (InstallExistingPackageTask) task.second;
             if (packageName.equals(installExistingPackageTask.getPackageName())) {
                 return;
             }
         }
         fail("InstallExistingPackageTask for " + packageName + " and userId " + userId
                 + " not executed");
     }
 }
	/*
	* Copyright 2016, The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.managedprovisioning.ota;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.fail;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.never;
	import static org.mockito.Mockito.verify;
	import static org.mockito.Mockito.when;

	import android.app.admin.DevicePolicyManager;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.pm.PackageManager;
	import android.content.pm.UserInfo;
	import android.os.UserHandle;
	import android.os.UserManager;
	import android.util.ArraySet;
	import android.util.Pair;

	import androidx.test.InstrumentationRegistry;
	import androidx.test.filters.SmallTest;

	import com.android.managedprovisioning.analytics.ProvisioningAnalyticsTracker;
	import com.android.managedprovisioning.task.AbstractProvisioningTask;
	import com.android.managedprovisioning.task.CrossProfileIntentFiltersSetter;
	import com.android.managedprovisioning.task.DeleteNonRequiredAppsTask;
	import com.android.managedprovisioning.task.DisableInstallShortcutListenersTask;
	import com.android.managedprovisioning.task.DisallowAddUserTask;
	import com.android.managedprovisioning.task.InstallExistingPackageTask;
	import com.android.managedprovisioning.task.MigrateSystemAppsSnapshotTask;

	import org.junit.Before;
	import org.junit.Test;
	import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;
	import java.util.function.IntFunction;

	/**
	* Unit tests for {@link OtaController}.
	*/
	@SmallTest
	public class OtaControllerTest {
	private static final int DEVICE_OWNER_USER_ID = 12;
	private static final int MANAGED_PROFILE_USER_ID = 15;
	private static final int MANAGED_USER_USER_ID = 18;

	private static final String DUMMY_SYSTEM_IME_PACKAGE_NAME =
	"com.android.inputmethod.dummysystemime";

	private static final ComponentName ADMIN_COMPONENT = new ComponentName("com.test.admin",
	".AdminReceiver");

	private static final IntFunction<ArraySet<String>> NO_MISSING_SYSTEM_IME_PROVIDER
	= userHandle -> new ArraySet<>();

	@Mock private Context mContext;
	@Mock private DevicePolicyManager mDevicePolicyManager;
	@Mock private PackageManager mPackageManager;
	@Mock private UserManager mUserManager;
	@Mock private CrossProfileIntentFiltersSetter mCrossProfileIntentFiltersSetter;
	@Mock private ProvisioningAnalyticsTracker mProvisioningAnalyticsTracker;

	private TaskExecutor mTaskExecutor;

	private List<Pair<Integer, AbstractProvisioningTask>> mTasks = new ArrayList<>();
	private List<UserInfo> mUsers = new ArrayList<>();
	private List<UserInfo> mProfiles = new ArrayList<>();

	@Before
	public void setUp() {
	MockitoAnnotations.initMocks(this);

	when(mContext.getSystemService(Context.DEVICE_POLICY_SERVICE))
	.thenReturn(mDevicePolicyManager);
	when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager);
	when(mContext.getPackageManager()).thenReturn(mPackageManager);
	when(mContext.getResources())
	.thenReturn(InstrumentationRegistry.getTargetContext().getResources());

	when(mUserManager.getUsers()).thenReturn(mUsers);
	when(mUserManager.getProfiles(UserHandle.USER_SYSTEM)).thenReturn(mProfiles);

	mTaskExecutor = new FakeTaskExecutor();

	addSystemUser();
	}

	@Test
	public void testDeviceOwnerSystemUser() {
	OtaController controller = new OtaController(mContext, mTaskExecutor,
	mCrossProfileIntentFiltersSetter, NO_MISSING_SYSTEM_IME_PROVIDER,
	mProvisioningAnalyticsTracker);

	// GIVEN that there is a device owner on the system user
	setDeviceOwner(UserHandle.USER_SYSTEM, ADMIN_COMPONENT);

	// WHEN running the OtaController
	controller.run();

	// THEN the task list should contain these tasks.
	assertTaskList(
	Pair.create(UserHandle.USER_SYSTEM, MigrateSystemAppsSnapshotTask.class),
	Pair.create(UserHandle.USER_SYSTEM, DeleteNonRequiredAppsTask.class),
	Pair.create(UserHandle.USER_SYSTEM, DisallowAddUserTask.class));

	// THEN cross profile intent filters setter should be invoked for system user
	verify(mCrossProfileIntentFiltersSetter).resetFilters(UserHandle.USER_SYSTEM);
	}

	@Test
	public void testDeviceOwnerSeparate() {
	OtaController controller = new OtaController(mContext, mTaskExecutor,
	mCrossProfileIntentFiltersSetter, NO_MISSING_SYSTEM_IME_PROVIDER,
	mProvisioningAnalyticsTracker);

	// GIVEN that there is a device owner on a non-system meat user
	addMeatUser(DEVICE_OWNER_USER_ID);
	setDeviceOwner(DEVICE_OWNER_USER_ID, ADMIN_COMPONENT);

	// WHEN running the OtaController
	controller.run();

	// THEN the task list should contain DeleteNonRequiredAppsTask and DisallowAddUserTask
	assertTaskList(
	Pair.create(UserHandle.USER_SYSTEM, MigrateSystemAppsSnapshotTask.class),
	Pair.create(DEVICE_OWNER_USER_ID, DeleteNonRequiredAppsTask.class),
	Pair.create(DEVICE_OWNER_USER_ID, DisallowAddUserTask.class));

	// THEN cross profile intent filters setter should be invoked for both users
	verify(mCrossProfileIntentFiltersSetter).resetFilters(UserHandle.USER_SYSTEM);
	verify(mCrossProfileIntentFiltersSetter).resetFilters(DEVICE_OWNER_USER_ID);
	}

	@Test
	public void testManagedProfileWithoutMissingSystemIme() {
	OtaController controller = new OtaController(mContext, mTaskExecutor,
	mCrossProfileIntentFiltersSetter, NO_MISSING_SYSTEM_IME_PROVIDER,
	mProvisioningAnalyticsTracker);

	// GIVEN that there is a managed profile
	addManagedProfile(MANAGED_PROFILE_USER_ID, ADMIN_COMPONENT);

	// WHEN running the OtaController
	controller.run();

	// THEN the task list should contain these tasks.
	assertTaskList(
	Pair.create(UserHandle.USER_SYSTEM, MigrateSystemAppsSnapshotTask.class),
	Pair.create(MANAGED_PROFILE_USER_ID, InstallExistingPackageTask.class),
	Pair.create(MANAGED_PROFILE_USER_ID, DisableInstallShortcutListenersTask.class),
	Pair.create(MANAGED_PROFILE_USER_ID, DeleteNonRequiredAppsTask.class));

	// THEN the cross profile intent filters should be reset
	verify(mCrossProfileIntentFiltersSetter).resetFilters(UserHandle.USER_SYSTEM);
	verify(mCrossProfileIntentFiltersSetter, never()).resetFilters(MANAGED_PROFILE_USER_ID);

	// THEN the DISALLOW_WALLPAPER restriction should be set
	verify(mUserManager).setUserRestriction(UserManager.DISALLOW_WALLPAPER, true,
	UserHandle.of(MANAGED_PROFILE_USER_ID));
	}

	@Test
	public void testManagedProfileWithMissingSystemIme() {
	IntFunction<ArraySet<String>> missingSystemImeProvider =
	(IntFunction<ArraySet<String>>) mock(IntFunction.class);

	OtaController controller = new OtaController(mContext, mTaskExecutor,
	mCrossProfileIntentFiltersSetter, missingSystemImeProvider,
	mProvisioningAnalyticsTracker);

	// GIVEN that there is a managed profile
	addManagedProfile(MANAGED_PROFILE_USER_ID, ADMIN_COMPONENT);

	// GIVEN that the managed profile does not have DUMMY_SYSTEM_IME_PACKAGE_NAME.
	ArraySet<String> missingImes = new ArraySet<>();
	missingImes.add(DUMMY_SYSTEM_IME_PACKAGE_NAME);
	when(missingSystemImeProvider.apply(MANAGED_PROFILE_USER_ID)).thenReturn(missingImes);

	// WHEN running the OtaController
	controller.run();

	// THEN the task list should contain these tasks.
	assertTaskList(
	Pair.create(UserHandle.USER_SYSTEM, MigrateSystemAppsSnapshotTask.class),
	Pair.create(MANAGED_PROFILE_USER_ID, InstallExistingPackageTask.class),
	Pair.create(MANAGED_PROFILE_USER_ID, InstallExistingPackageTask.class),
	Pair.create(MANAGED_PROFILE_USER_ID, DisableInstallShortcutListenersTask.class),
	Pair.create(MANAGED_PROFILE_USER_ID, DeleteNonRequiredAppsTask.class));

	// THEN the cross profile intent filters should be reset
	verify(mCrossProfileIntentFiltersSetter).resetFilters(UserHandle.USER_SYSTEM);
	verify(mCrossProfileIntentFiltersSetter, never()).resetFilters(MANAGED_PROFILE_USER_ID);

	// THEN the DISALLOW_WALLPAPER restriction should be set
	verify(mUserManager).setUserRestriction(UserManager.DISALLOW_WALLPAPER, true,
	UserHandle.of(MANAGED_PROFILE_USER_ID));

	// THEN the DUMMY_SYSTEM_IME_PACKAGE_NAME should be installed.
	assertInstallExistingPackageTask(MANAGED_PROFILE_USER_ID, DUMMY_SYSTEM_IME_PACKAGE_NAME);
	}

	@Test
	public void testManagedUser() {
	OtaController controller = new OtaController(mContext, mTaskExecutor,
	mCrossProfileIntentFiltersSetter, NO_MISSING_SYSTEM_IME_PROVIDER,
	mProvisioningAnalyticsTracker);

	// GIVEN that there is a managed profile
	addManagedUser(MANAGED_USER_USER_ID, ADMIN_COMPONENT);

	// WHEN running the OtaController
	controller.run();

	// THEN the task list should contain these tasks.
	assertTaskList(
	Pair.create(UserHandle.USER_SYSTEM, MigrateSystemAppsSnapshotTask.class),
	Pair.create(MANAGED_USER_USER_ID, DeleteNonRequiredAppsTask.class));
	}

	private class FakeTaskExecutor extends TaskExecutor {

	public FakeTaskExecutor() {
	super();
	}

	@Override
	public synchronized void execute(int userId, AbstractProvisioningTask task) {
	mTasks.add(Pair.create(userId, task));
	}
	}

	private void addMeatUser(int userId) {
	UserInfo ui = new UserInfo(userId, null, 0);
	mUsers.add(ui);
	when(mUserManager.getProfiles(userId)).thenReturn(Collections.singletonList(ui));
	}

	private void setDeviceOwner(int userId, ComponentName admin) {
	when(mDevicePolicyManager.getDeviceOwnerUserId()).thenReturn(userId);
	when(mDevicePolicyManager.getDeviceOwnerComponentOnAnyUser()).thenReturn(admin);
	}

	private void addManagedProfile(int userId, ComponentName admin) {
	UserInfo ui = new UserInfo(userId, null, UserInfo.FLAG_MANAGED_PROFILE);
	mUsers.add(ui);
	when(mDevicePolicyManager.getProfileOwnerAsUser(userId)).thenReturn(admin);
	when(mUserManager.getProfiles(userId)).thenReturn(Collections.singletonList(ui));
	mProfiles.add(ui);
	}

	private void addManagedUser(int userId, ComponentName admin) {
	UserInfo ui = new UserInfo(userId, null, 0);
	mUsers.add(ui);
	when(mDevicePolicyManager.getProfileOwnerAsUser(userId)).thenReturn(admin);
	}

	private void addSystemUser() {
	UserInfo ui = new UserInfo(UserHandle.USER_SYSTEM, null, UserInfo.FLAG_PRIMARY);
	mUsers.add(ui);
	mProfiles.add(ui);
	}

	private void assertTaskList(Pair<Integer, Class>... tasks) {
	assertEquals(tasks.length, mTasks.size());

	for (Pair<Integer, Class> task : tasks) {
	assertTaskListContains(task.first, task.second);
	}
	}

	private void assertTaskListContains(Integer userId, Class taskClass) {
	for (Pair<Integer, AbstractProvisioningTask> task : mTasks) {
	if (userId == task.first && taskClass.isInstance(task.second)) {
	return;
	}
	}
	fail("Task for class " + taskClass + " and userId " + userId + " not executed");
	}

	private void assertInstallExistingPackageTask(int userId, String packageName) {
	for (Pair<Integer, AbstractProvisioningTask> task : mTasks) {
	if (userId != task.first \|\| !InstallExistingPackageTask.class.isInstance(task.second)) {
	continue;
	}
	InstallExistingPackageTask installExistingPackageTask =
	(InstallExistingPackageTask) task.second;
	if (packageName.equals(installExistingPackageTask.getPackageName())) {
	return;
	}
	}
	fail("InstallExistingPackageTask for " + packageName + " and userId " + userId
	+ " not executed");
	}
	}