Fix getCanForwardToProfileIdMapInternal implementation to resolve cross profile access.

* Ensure that CrossProfileIntentForwarderActivity resolution is accurate.
  This relies on the @hide property `targetUserId` by accessing it via
  reflection as there is no API that can surface this information for
  `module_current` targets.
* Add test cases for devices that may be configured to have more than
  one managed profile, and may not be compatible with AOSP source code
  assumption to ensure CrossProfile detection fails closed.

Bug: b/394231676
Test: atest MediaProviderTests:UserManagerStateTest
Flag: EXEMPT bugfix
Change-Id: Id2a452e29218f9625d32a081ec8f0cf8508d2a0b

1 files changed, 368 insertions, 276 deletions

diff --git a/tests/unit/com/android/documentsui/UserManagerStateTest.java b/tests/unit/com/android/documentsui/UserManagerStateTest.java
index 6f869dcd5..9d629c574 100644
--- a/tests/unit/com/android/documentsui/UserManagerStateTest.java
+++ b/tests/unit/com/android/documentsui/UserManagerStateTest.java
@@ -23,8 +23,11 @@ import static com.android.documentsui.DevicePolicyResources.Strings.WORK_TAB;
 
 import static com.google.common.truth.Truth.assertWithMessage;
 
+import static org.junit.Assume.assumeTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyInt;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -64,16 +67,37 @@ import java.util.Map;
 @SdkSuppress(minSdkVersion = 31, codeName = "S")
 public class UserManagerStateTest {
 
+    /**
+     * Class that exposes the @hide api [targetUserId] in order to supply proper values for
+     * reflection based code that is inspecting this field.
+     *
+     * @property targetUserId
+     */
+    private static class ReflectedResolveInfo extends ResolveInfo {
+
+        public int targetUserId;
+
+        ReflectedResolveInfo(int targetUserId) {
+            this.targetUserId = targetUserId;
+        }
+
+        @Override
+        public boolean isCrossProfileIntentForwarderActivity() {
+            return true;
+        }
+    }
+
     private static final String PERSONAL = "Personal";
     private static final String WORK = "Work";
     private static final String PRIVATE = "Private";
     private static final String PACKAGE_NAME = "com.android.documentsui";
 
     /**
-     * Assume that the current user is SYSTEM_USER.
-     * For HSUM targets, the primary user is set as the system user.
+     * Assume that the current user is SYSTEM_USER. For HSUM targets, the primary user is set as the
+     * system user.
      */
     private final int mCurrentUserId = UserHandle.myUserId();
+
     private final UserHandle mPrimaryUser = UserHandle.of(mCurrentUserId);
     private final UserHandle mSystemUser = mPrimaryUser == null ? UserHandle.SYSTEM : mPrimaryUser;
     private final UserHandle mManagedUser = UserHandle.of(mCurrentUserId + 10);
@@ -81,12 +105,15 @@ public class UserManagerStateTest {
     private final UserHandle mOtherUser = UserHandle.of(mCurrentUserId + 30);
     private final UserHandle mNormalUser = UserHandle.of(mCurrentUserId + 40);
 
-    private final ResolveInfo mMockInfo1 = mock(ResolveInfo.class);
-    private final ResolveInfo mMockInfo2 = mock(ResolveInfo.class);
-    private final ResolveInfo mMockInfo3 = mock(ResolveInfo.class);
+    private final ResolveInfo mMockInfoPrimaryUser =
+            new ReflectedResolveInfo(mPrimaryUser.getIdentifier());
+    private final ResolveInfo mMockInfoManagedUser =
+            new ReflectedResolveInfo(mManagedUser.getIdentifier());
+    private final ResolveInfo mMockInfoPrivateUser =
+            new ReflectedResolveInfo(mPrivateUser.getIdentifier());
 
     private final Context mMockContext = mock(Context.class);
-    private final Intent mMockIntent = mock(Intent.class);
+    private final Intent mMockIntent = new Intent();
     private final UserManager mMockUserManager = UserManagers.create();
     private final PackageManager mMockPackageManager = mock(PackageManager.class);
     private final DevicePolicyManager mDevicePolicyManager = mock(DevicePolicyManager.class);
@@ -95,6 +122,8 @@ public class UserManagerStateTest {
     @Before
     public void setup() throws Exception {
         when(mMockContext.getApplicationContext()).thenReturn(mMockContext);
+        when(mMockContext.createContextAsUser(any(UserHandle.class), anyInt()))
+                .thenReturn(mMockContext);
 
         when(mMockUserManager.isManagedProfile(mManagedUser.getIdentifier())).thenReturn(true);
         when(mMockUserManager.isManagedProfile(mSystemUser.getIdentifier())).thenReturn(false);
@@ -102,54 +131,60 @@ public class UserManagerStateTest {
         when(mMockUserManager.isManagedProfile(mOtherUser.getIdentifier())).thenReturn(false);
 
         if (SdkLevel.isAtLeastV()) {
-            UserProperties systemUserProperties = new UserProperties.Builder()
-                    .setShowInSharingSurfaces(UserProperties.SHOW_IN_SHARING_SURFACES_SEPARATE)
-                    .setCrossProfileContentSharingStrategy(
-                            UserProperties.CROSS_PROFILE_CONTENT_SHARING_NO_DELEGATION)
-                    .build();
-            UserProperties managedUserProperties = new UserProperties.Builder()
-                    .setShowInSharingSurfaces(UserProperties.SHOW_IN_SHARING_SURFACES_SEPARATE)
-                    .setCrossProfileContentSharingStrategy(
-                            UserProperties.CROSS_PROFILE_CONTENT_SHARING_NO_DELEGATION)
-                    .setShowInQuietMode(UserProperties.SHOW_IN_QUIET_MODE_PAUSED)
-                    .build();
-            UserProperties privateUserProperties = new UserProperties.Builder()
-                    .setShowInSharingSurfaces(UserProperties.SHOW_IN_SHARING_SURFACES_SEPARATE)
-                    .setCrossProfileContentSharingStrategy(
-                            UserProperties.CROSS_PROFILE_CONTENT_SHARING_DELEGATE_FROM_PARENT)
-                    .setShowInQuietMode(UserProperties.SHOW_IN_QUIET_MODE_HIDDEN)
-                    .build();
-            UserProperties otherUserProperties = new UserProperties.Builder()
-                    .setShowInSharingSurfaces(UserProperties.SHOW_IN_SHARING_SURFACES_WITH_PARENT)
-                    .setCrossProfileContentSharingStrategy(
-                            UserProperties.CROSS_PROFILE_CONTENT_SHARING_DELEGATE_FROM_PARENT)
-                    .build();
-            UserProperties normalUserProperties = new UserProperties.Builder()
-                    .setShowInSharingSurfaces(UserProperties.SHOW_IN_SHARING_SURFACES_NO)
-                    .setCrossProfileContentSharingStrategy(
-                            UserProperties.CROSS_PROFILE_CONTENT_SHARING_DELEGATE_FROM_PARENT)
-                    .build();
+            UserProperties systemUserProperties =
+                    new UserProperties.Builder()
+                            .setShowInSharingSurfaces(
+                                    UserProperties.SHOW_IN_SHARING_SURFACES_SEPARATE)
+                            .setCrossProfileContentSharingStrategy(
+                                    UserProperties.CROSS_PROFILE_CONTENT_SHARING_NO_DELEGATION)
+                            .build();
+            UserProperties managedUserProperties =
+                    new UserProperties.Builder()
+                            .setShowInSharingSurfaces(
+                                    UserProperties.SHOW_IN_SHARING_SURFACES_SEPARATE)
+                            .setCrossProfileContentSharingStrategy(
+                                    UserProperties.CROSS_PROFILE_CONTENT_SHARING_NO_DELEGATION)
+                            .setShowInQuietMode(UserProperties.SHOW_IN_QUIET_MODE_PAUSED)
+                            .build();
+            UserProperties privateUserProperties =
+                    new UserProperties.Builder()
+                            .setShowInSharingSurfaces(
+                                    UserProperties.SHOW_IN_SHARING_SURFACES_SEPARATE)
+                            .setCrossProfileContentSharingStrategy(
+                                    UserProperties
+                                            .CROSS_PROFILE_CONTENT_SHARING_DELEGATE_FROM_PARENT)
+                            .setShowInQuietMode(UserProperties.SHOW_IN_QUIET_MODE_HIDDEN)
+                            .build();
+            UserProperties otherUserProperties =
+                    new UserProperties.Builder()
+                            .setShowInSharingSurfaces(
+                                    UserProperties.SHOW_IN_SHARING_SURFACES_WITH_PARENT)
+                            .setCrossProfileContentSharingStrategy(
+                                    UserProperties
+                                            .CROSS_PROFILE_CONTENT_SHARING_DELEGATE_FROM_PARENT)
+                            .build();
+            UserProperties normalUserProperties =
+                    new UserProperties.Builder()
+                            .setShowInSharingSurfaces(UserProperties.SHOW_IN_SHARING_SURFACES_NO)
+                            .setCrossProfileContentSharingStrategy(
+                                    UserProperties
+                                            .CROSS_PROFILE_CONTENT_SHARING_DELEGATE_FROM_PARENT)
+                            .build();
             when(mMockUserManager.getUserProperties(mSystemUser)).thenReturn(systemUserProperties);
-            when(mMockUserManager.getUserProperties(mManagedUser)).thenReturn(
-                    managedUserProperties);
-            when(mMockUserManager.getUserProperties(mPrivateUser)).thenReturn(
-                    privateUserProperties);
+            when(mMockUserManager.getUserProperties(mManagedUser))
+                    .thenReturn(managedUserProperties);
+            when(mMockUserManager.getUserProperties(mPrivateUser))
+                    .thenReturn(privateUserProperties);
             when(mMockUserManager.getUserProperties(mOtherUser)).thenReturn(otherUserProperties);
             when(mMockUserManager.getUserProperties(mNormalUser)).thenReturn(normalUserProperties);
         }
 
         when(mMockUserManager.getProfileParent(mSystemUser)).thenReturn(null);
-        when(mMockUserManager.getProfileParent(mManagedUser)).thenReturn(mSystemUser);
-        when(mMockUserManager.getProfileParent(mPrivateUser)).thenReturn(mSystemUser);
-        when(mMockUserManager.getProfileParent(mOtherUser)).thenReturn(mSystemUser);
+        when(mMockUserManager.getProfileParent(mManagedUser)).thenReturn(mPrimaryUser);
+        when(mMockUserManager.getProfileParent(mPrivateUser)).thenReturn(mPrimaryUser);
+        when(mMockUserManager.getProfileParent(mOtherUser)).thenReturn(mPrimaryUser);
         when(mMockUserManager.getProfileParent(mNormalUser)).thenReturn(null);
 
-        if (SdkLevel.isAtLeastR()) {
-            when(mMockInfo1.isCrossProfileIntentForwarderActivity()).thenReturn(true);
-            when(mMockInfo2.isCrossProfileIntentForwarderActivity()).thenReturn(false);
-            when(mMockInfo3.isCrossProfileIntentForwarderActivity()).thenReturn(false);
-        }
-
         when(mMockContext.getPackageManager()).thenReturn(mMockPackageManager);
         when(mMockContext.getSystemServiceName(UserManager.class)).thenReturn("mMockUserManager");
         when(mMockContext.getSystemService(UserManager.class)).thenReturn(mMockUserManager);
@@ -157,22 +192,25 @@ public class UserManagerStateTest {
                 .thenReturn(Context.DEVICE_POLICY_SERVICE);
         when(mMockContext.getSystemService(Context.DEVICE_POLICY_SERVICE))
                 .thenReturn(mDevicePolicyManager);
-        when(mMockContext.getResources()).thenReturn(
-                InstrumentationRegistry.getInstrumentation().getTargetContext().getResources());
+        when(mMockContext.getResources())
+                .thenReturn(
+                        InstrumentationRegistry.getInstrumentation()
+                                .getTargetContext()
+                                .getResources());
 
         when(mMockContext.getPackageName()).thenReturn(PACKAGE_NAME);
-        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mSystemUser)).thenReturn(
-                mMockContext);
-        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mManagedUser)).thenReturn(
-                mMockContext);
-        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mPrivateUser)).thenReturn(
-                mMockContext);
-        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mOtherUser)).thenReturn(
-                mMockContext);
-        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mNormalUser)).thenReturn(
-                mMockContext);
-        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mPrimaryUser)).thenReturn(
-                mMockContext);
+        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mSystemUser))
+                .thenReturn(mMockContext);
+        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mManagedUser))
+                .thenReturn(mMockContext);
+        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mPrivateUser))
+                .thenReturn(mMockContext);
+        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mOtherUser))
+                .thenReturn(mMockContext);
+        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mNormalUser))
+                .thenReturn(mMockContext);
+        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, 0, mPrimaryUser))
+                .thenReturn(mMockContext);
     }
 
     @Test
@@ -181,48 +219,52 @@ public class UserManagerStateTest {
         initializeUserManagerState(currentUser, Lists.newArrayList(mSystemUser));
 
         assertWithMessage("getUserIds returns unexpected list of user ids")
-                .that(mUserManagerState.getUserIds()).containsExactly(UserId.of(mSystemUser));
+                .that(mUserManagerState.getUserIds())
+                .containsExactly(UserId.of(mSystemUser));
     }
 
     @Test
     public void testGetUserIds_allProfilesCurrentUserSystem_allShowInSharingSurfacesSeparate() {
         if (!SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mSystemUser);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser, mOtherUser,
-                        mNormalUser));
+        initializeUserManagerState(
+                currentUser,
+                Lists.newArrayList(
+                        mSystemUser, mManagedUser, mPrivateUser, mOtherUser, mNormalUser));
 
         assertWithMessage("getUserIds returns unexpected list of user ids")
                 .that(mUserManagerState.getUserIds())
-                .containsExactly(UserId.of(mSystemUser), UserId.of(mManagedUser),
-                        UserId.of(mPrivateUser));
+                .containsExactly(
+                        UserId.of(mSystemUser), UserId.of(mManagedUser), UserId.of(mPrivateUser));
     }
 
     @Test
     public void testGetUserIds_allProfilesCurrentUserManaged_allShowInSharingSurfacesSeparate() {
         if (!SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mManagedUser);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser, mOtherUser,
-                        mNormalUser));
+        initializeUserManagerState(
+                currentUser,
+                Lists.newArrayList(
+                        mSystemUser, mManagedUser, mPrivateUser, mOtherUser, mNormalUser));
 
         assertWithMessage("getUserIds returns unexpected list of user ids")
                 .that(mUserManagerState.getUserIds())
-                .containsExactly(UserId.of(mSystemUser), UserId.of(mManagedUser),
-                        UserId.of(mPrivateUser));
+                .containsExactly(
+                        UserId.of(mSystemUser), UserId.of(mManagedUser), UserId.of(mPrivateUser));
     }
 
     @Test
     public void testGetUserIds_allProfilesCurrentUserPrivate_allShowInSharingSurfacesSeparate() {
         if (!SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mPrivateUser);
-        initializeUserManagerState(currentUser,
+        initializeUserManagerState(
+                currentUser,
                 Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser, mOtherUser));
 
         assertWithMessage("getUserIds returns unexpected list of user ids")
                 .that(mUserManagerState.getUserIds())
-                .containsExactly(UserId.of(mSystemUser), UserId.of(mManagedUser),
-                        UserId.of(mPrivateUser));
+                .containsExactly(
+                        UserId.of(mSystemUser), UserId.of(mManagedUser), UserId.of(mPrivateUser));
     }
 
     @Test
@@ -291,7 +333,8 @@ public class UserManagerStateTest {
 
     @Test
     public void testGetUserIds_normalAndOtherUserCurrentUserNormal_returnsCurrentUser() {
-        // since both users do not have show in sharing surfaces separate, returns current user
+        // since both users do not have show in sharing surfaces separate, returns
+        // current user
         UserId currentUser = UserId.of(mNormalUser);
         initializeUserManagerState(currentUser, Lists.newArrayList(mOtherUser, mNormalUser));
 
@@ -308,7 +351,8 @@ public class UserManagerStateTest {
         initializeUserManagerState(currentUser, Lists.newArrayList(mSystemUser, mManagedUser));
         assertWithMessage("getUserIds returns unexpected list of user ids")
                 .that(mUserManagerState.getUserIds())
-                .containsExactly(UserId.of(mSystemUser), UserId.of(mManagedUser)).inOrder();
+                .containsExactly(UserId.of(mSystemUser), UserId.of(mManagedUser))
+                .inOrder();
     }
 
     @Test
@@ -319,66 +363,79 @@ public class UserManagerStateTest {
         initializeUserManagerState(currentUser, Lists.newArrayList(mSystemUser, mManagedUser));
         assertWithMessage("getUserIds returns unexpected list of user ids")
                 .that(mUserManagerState.getUserIds())
-                .containsExactly(UserId.of(mSystemUser), UserId.of(mManagedUser)).inOrder();
+                .containsExactly(UserId.of(mSystemUser), UserId.of(mManagedUser))
+                .inOrder();
     }
 
     @Test
     public void testGetUserIds_managedAndSystemUserCurrentUserSystem_returnsBothInOrder() {
-        // Returns the both if there are system and managed users, regardless of input list order.
+        // Returns the both if there are system and managed users, regardless of input
+        // list order.
         if (SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mSystemUser);
         initializeUserManagerState(currentUser, Lists.newArrayList(mManagedUser, mSystemUser));
         assertWithMessage("getUserIds returns unexpected list of user ids")
                 .that(mUserManagerState.getUserIds())
-                .containsExactly(UserId.of(mSystemUser), UserId.of(mManagedUser)).inOrder();
+                .containsExactly(UserId.of(mSystemUser), UserId.of(mManagedUser))
+                .inOrder();
     }
 
     @Test
     public void testGetUserIds_otherAndManagedUserCurrentUserOtherPreV_returnsCurrentUser() {
         // When there is no system user, returns the current user.
-        // This is a case theoretically can happen but we don't expect. So we return the current
+        // This is a case theoretically can happen but we don't expect. So we return the
+        // current
         // user only.
         if (SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mOtherUser);
         initializeUserManagerState(currentUser, Lists.newArrayList(mOtherUser, mManagedUser));
         assertWithMessage("getUserIds returns unexpected list of user ids")
-                .that(mUserManagerState.getUserIds()).containsExactly(currentUser);
+                .that(mUserManagerState.getUserIds())
+                .containsExactly(currentUser);
     }
 
     @Test
     public void testGetUserIds_otherAndManagedUserCurrentUserOtherPostV_returnsManagedUser() {
-        // Only the users with show in sharing surfaces separate are eligible to be returned
+        // Only the users with show in sharing surfaces separate are eligible to be
+        // returned
         if (!SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mOtherUser);
         initializeUserManagerState(currentUser, Lists.newArrayList(mOtherUser, mManagedUser));
         assertWithMessage("getUserIds returns unexpected list of user ids")
-                .that(mUserManagerState.getUserIds()).containsExactly(UserId.of(mManagedUser));
+                .that(mUserManagerState.getUserIds())
+                .containsExactly(UserId.of(mManagedUser));
     }
 
     @Test
     public void testGetUserIds_otherAndManagedUserCurrentUserManaged_returnsCurrentUser() {
         // When there is no system user, returns the current user.
-        // This is a case theoretically can happen, but we don't expect. So we return the current
+        // This is a case theoretically can happen, but we don't expect. So we return
+        // the current
         // user only.
         UserId currentUser = UserId.of(mManagedUser);
         initializeUserManagerState(currentUser, Lists.newArrayList(mOtherUser, mManagedUser));
         assertWithMessage("getUserIds returns unexpected list of user ids")
-                .that(mUserManagerState.getUserIds()).containsExactly(currentUser);
+                .that(mUserManagerState.getUserIds())
+                .containsExactly(currentUser);
     }
 
     @Test
     public void testGetUserIds_unsupportedDeviceCurrent_returnsCurrentUser() {
-        // This test only tests for Android R or later. This test case always passes before R.
+        // This test only tests for Android R or later. This test case always passes
+        // before R.
         if (VersionUtils.isAtLeastR()) {
             // When permission is denied, only returns the current user.
             when(mMockContext.checkSelfPermission(Manifest.permission.INTERACT_ACROSS_USERS))
                     .thenReturn(PackageManager.PERMISSION_DENIED);
             UserId currentUser = UserId.of(mSystemUser);
-            when(mMockUserManager.getUserProfiles()).thenReturn(
-                    Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser, mOtherUser));
+            when(mMockUserManager.getUserProfiles())
+                    .thenReturn(
+                            Lists.newArrayList(
+                                    mSystemUser, mManagedUser, mPrivateUser, mOtherUser));
             mUserManagerState = UserManagerState.create(mMockContext);
             assertWithMessage("Unsupported device should have returned only the current user")
-                    .that(mUserManagerState.getUserIds()).containsExactly(currentUser);
+                    .that(mUserManagerState.getUserIds())
+                    .containsExactly(currentUser);
         }
     }
 
@@ -386,7 +443,8 @@ public class UserManagerStateTest {
     public void testGetUserIds_returnCachedList() {
         // Returns all three if there are system, managed and private users.
         UserId currentUser = UserId.of(mSystemUser);
-        initializeUserManagerState(currentUser,
+        initializeUserManagerState(
+                currentUser,
                 Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser, mOtherUser));
         assertWithMessage("getUserIds does not return cached instance")
                 .that(mUserManagerState.getUserIds())
@@ -394,47 +452,13 @@ public class UserManagerStateTest {
     }
 
     @Test
-    public void testGetCanForwardToProfileIdMap_systemUserCanForwardToAll() {
-        UserId currentUser = UserId.of(mSystemUser);
-        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfo1, mMockInfo2);
-        if (SdkLevel.isAtLeastV()) {
-            initializeUserManagerState(currentUser,
-                    Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
-            when(mMockPackageManager.queryIntentActivitiesAsUser(mMockIntent,
-                    PackageManager.MATCH_DEFAULT_ONLY, mSystemUser)).thenReturn(
-                    mMockResolveInfoList);
-        } else {
-            initializeUserManagerState(currentUser,
-                    Lists.newArrayList(mSystemUser, mManagedUser));
-            when(mMockPackageManager.queryIntentActivities(mMockIntent,
-                    PackageManager.MATCH_DEFAULT_ONLY)).thenReturn(mMockResolveInfoList);
-        }
-
-        Map<UserId, Boolean> expectedCanForwardToProfileIdMap = new HashMap<>();
-        expectedCanForwardToProfileIdMap.put(UserId.of(mSystemUser), true);
-        expectedCanForwardToProfileIdMap.put(UserId.of(mManagedUser), true);
-        if (SdkLevel.isAtLeastV()) {
-            expectedCanForwardToProfileIdMap.put(UserId.of(mPrivateUser), true);
-        }
-
-        assertWithMessage("getCanForwardToProfileIdMap returns incorrect mappings")
-                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent))
-                .isEqualTo(expectedCanForwardToProfileIdMap);
-    }
-
-    @Test
     public void testGetCanForwardToProfileIdMap_systemUserCanForwardToManaged() {
         UserId currentUser = UserId.of(mSystemUser);
         initializeUserManagerState(currentUser, Lists.newArrayList(mSystemUser, mManagedUser));
-        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfo1, mMockInfo2);
-        if (SdkLevel.isAtLeastV()) {
-            when(mMockPackageManager.queryIntentActivitiesAsUser(mMockIntent,
-                    PackageManager.MATCH_DEFAULT_ONLY, mSystemUser)).thenReturn(
-                    mMockResolveInfoList);
-        } else {
-            when(mMockPackageManager.queryIntentActivities(mMockIntent,
-                    PackageManager.MATCH_DEFAULT_ONLY)).thenReturn(mMockResolveInfoList);
-        }
+        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfoManagedUser);
+
+        when(mMockPackageManager.queryIntentActivities(any(Intent.class), anyInt()))
+                .thenReturn(mMockResolveInfoList);
 
         Map<UserId, Boolean> expectedCanForwardToProfileIdMap = new HashMap<>();
         expectedCanForwardToProfileIdMap.put(UserId.of(mSystemUser), true);
@@ -463,18 +487,19 @@ public class UserManagerStateTest {
     @Test
     public void testGetCanForwardToProfileIdMap_systemUserCanNotForwardToManagedUser() {
         UserId currentUser = UserId.of(mSystemUser);
-        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfo2, mMockInfo3);
+        final List<ResolveInfo> mMockResolveInfoList =
+                Lists.newArrayList(mMockInfoPrivateUser, mMockInfoPrimaryUser);
         if (SdkLevel.isAtLeastV()) {
-            initializeUserManagerState(currentUser,
-                    Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
-            when(mMockPackageManager.queryIntentActivitiesAsUser(mMockIntent,
-                    PackageManager.MATCH_DEFAULT_ONLY, mSystemUser)).thenReturn(
-                    mMockResolveInfoList);
+            initializeUserManagerState(
+                    currentUser, Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
+            when(mMockPackageManager.queryIntentActivitiesAsUser(
+                            mMockIntent, PackageManager.MATCH_DEFAULT_ONLY, mSystemUser))
+                    .thenReturn(mMockResolveInfoList);
         } else {
-            initializeUserManagerState(currentUser,
-                    Lists.newArrayList(mSystemUser, mManagedUser));
-            when(mMockPackageManager.queryIntentActivities(mMockIntent,
-                    PackageManager.MATCH_DEFAULT_ONLY)).thenReturn(mMockResolveInfoList);
+            initializeUserManagerState(currentUser, Lists.newArrayList(mSystemUser, mManagedUser));
+            when(mMockPackageManager.queryIntentActivities(
+                            mMockIntent, PackageManager.MATCH_DEFAULT_ONLY))
+                    .thenReturn(mMockResolveInfoList);
         }
 
         Map<UserId, Boolean> expectedCanForwardToProfileIdMap = new HashMap<>();
@@ -492,26 +517,17 @@ public class UserManagerStateTest {
     @Test
     public void testGetCanForwardToProfileIdMap_managedCanForwardToAll() {
         UserId currentUser = UserId.of(mManagedUser);
-        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfo1, mMockInfo2);
-        if (SdkLevel.isAtLeastV()) {
-            initializeUserManagerState(currentUser,
-                    Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
-            when(mMockPackageManager.queryIntentActivitiesAsUser(mMockIntent,
-                    PackageManager.MATCH_DEFAULT_ONLY, mManagedUser)).thenReturn(
-                    mMockResolveInfoList);
-        } else {
-            initializeUserManagerState(currentUser,
-                    Lists.newArrayList(mSystemUser, mManagedUser));
-            when(mMockPackageManager.queryIntentActivities(mMockIntent,
-                    PackageManager.MATCH_DEFAULT_ONLY)).thenReturn(mMockResolveInfoList);
-        }
+        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfoPrimaryUser);
+        when(mMockPackageManager.queryIntentActivities(any(Intent.class), anyInt()))
+                .thenReturn(mMockResolveInfoList);
+
+        initializeUserManagerState(
+                currentUser, Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
 
         Map<UserId, Boolean> expectedCanForwardToProfileIdMap = new HashMap<>();
         expectedCanForwardToProfileIdMap.put(UserId.of(mSystemUser), true);
         expectedCanForwardToProfileIdMap.put(UserId.of(mManagedUser), true);
-        if (SdkLevel.isAtLeastV()) {
-            expectedCanForwardToProfileIdMap.put(UserId.of(mPrivateUser), true);
-        }
+        expectedCanForwardToProfileIdMap.put(UserId.of(mPrivateUser), true);
 
         assertWithMessage("getCanForwardToProfileIdMap returns incorrect mappings")
                 .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent))
@@ -521,19 +537,20 @@ public class UserManagerStateTest {
     @Test
     public void testGetCanForwardToProfileIdMap_managedCanNotForwardToAll() {
         UserId currentUser = UserId.of(mManagedUser);
-        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfo2, mMockInfo3);
+        final List<ResolveInfo> mMockResolveInfoList =
+                Lists.newArrayList(mMockInfoPrivateUser, mMockInfoPrimaryUser);
 
         if (SdkLevel.isAtLeastV()) {
-            initializeUserManagerState(currentUser,
-                    Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
-            when(mMockPackageManager.queryIntentActivitiesAsUser(mMockIntent,
-                    PackageManager.MATCH_DEFAULT_ONLY, mSystemUser)).thenReturn(
-                    mMockResolveInfoList);
+            initializeUserManagerState(
+                    currentUser, Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
+            when(mMockPackageManager.queryIntentActivitiesAsUser(
+                            mMockIntent, PackageManager.MATCH_DEFAULT_ONLY, mSystemUser))
+                    .thenReturn(mMockResolveInfoList);
         } else {
-            initializeUserManagerState(currentUser,
-                    Lists.newArrayList(mSystemUser, mManagedUser));
-            when(mMockPackageManager.queryIntentActivities(mMockIntent,
-                    PackageManager.MATCH_DEFAULT_ONLY)).thenReturn(mMockResolveInfoList);
+            initializeUserManagerState(currentUser, Lists.newArrayList(mSystemUser, mManagedUser));
+            when(mMockPackageManager.queryIntentActivities(
+                            mMockIntent, PackageManager.MATCH_DEFAULT_ONLY))
+                    .thenReturn(mMockResolveInfoList);
         }
 
         Map<UserId, Boolean> expectedCanForwardToProfileIdMap = new HashMap<>();
@@ -550,13 +567,13 @@ public class UserManagerStateTest {
 
     @Test
     public void testGetCanForwardToProfileIdMap_privateCanForwardToAll() {
-        if (!SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mPrivateUser);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
-        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfo1, mMockInfo2);
-        when(mMockPackageManager.queryIntentActivitiesAsUser(mMockIntent,
-                PackageManager.MATCH_DEFAULT_ONLY, mSystemUser)).thenReturn(mMockResolveInfoList);
+        initializeUserManagerState(
+                currentUser, Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
+        final List<ResolveInfo> mMockResolveInfoList =
+                Lists.newArrayList(mMockInfoPrimaryUser, mMockInfoManagedUser);
+        when(mMockPackageManager.queryIntentActivities(any(Intent.class), anyInt()))
+                .thenReturn(mMockResolveInfoList);
 
         Map<UserId, Boolean> expectedCanForwardToProfileIdMap = new HashMap<>();
         expectedCanForwardToProfileIdMap.put(UserId.of(mSystemUser), true);
@@ -570,13 +587,13 @@ public class UserManagerStateTest {
 
     @Test
     public void testGetCanForwardToProfileIdMap_privateCanNotForwardToManagedUser() {
-        if (!SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mPrivateUser);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
-        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfo2, mMockInfo3);
-        when(mMockPackageManager.queryIntentActivitiesAsUser(mMockIntent,
-                PackageManager.MATCH_DEFAULT_ONLY, mSystemUser)).thenReturn(mMockResolveInfoList);
+        initializeUserManagerState(
+                currentUser, Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
+        final List<ResolveInfo> mMockResolveInfoList =
+                Lists.newArrayList(mMockInfoPrivateUser, mMockInfoPrimaryUser);
+        when(mMockPackageManager.queryIntentActivities(any(Intent.class), anyInt()))
+                .thenReturn(mMockResolveInfoList);
 
         Map<UserId, Boolean> expectedCanForwardToProfileIdMap = new HashMap<>();
         expectedCanForwardToProfileIdMap.put(UserId.of(mSystemUser), true);
@@ -594,6 +611,10 @@ public class UserManagerStateTest {
         UserId currentUser = UserId.of(mPrivateUser);
         initializeUserManagerState(currentUser, Lists.newArrayList(mSystemUser, mPrivateUser));
 
+        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfoPrimaryUser);
+        when(mMockPackageManager.queryIntentActivities(any(Intent.class), anyInt()))
+                .thenReturn(mMockResolveInfoList);
+
         Map<UserId, Boolean> expectedCanForwardToProfileIdMap = new HashMap<>();
         expectedCanForwardToProfileIdMap.put(UserId.of(mSystemUser), true);
         expectedCanForwardToProfileIdMap.put(UserId.of(mPrivateUser), true);
@@ -607,24 +628,27 @@ public class UserManagerStateTest {
     public void testOnProfileStatusChange_anyIntentActionForManagedProfile() {
         if (!SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mSystemUser);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
+        initializeUserManagerState(
+                currentUser, Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
 
-        // UserManagerState#mUserId and UserManagerState#mCanForwardToProfileIdMap will empty
+        // UserManagerState#mUserId and UserManagerState#mCanForwardToProfileIdMap will
+        // empty
         // by default if the getters of these member variables have not been called
         List<UserId> userIdsBeforeIntent = new ArrayList<>(mUserManagerState.getUserIds());
-        Map<UserId, Boolean> canForwardToProfileIdMapBeforeIntent = new HashMap<>(
-                mUserManagerState.getCanForwardToProfileIdMap(mMockIntent));
+        Map<UserId, Boolean> canForwardToProfileIdMapBeforeIntent =
+                new HashMap<>(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent));
 
         String action = "any_intent";
         mUserManagerState.onProfileActionStatusChange(action, UserId.of(mManagedUser));
 
         assertWithMessage("Unexpected changes to user id list on receiving intent: " + action)
-                .that(mUserManagerState.getUserIds()).isEqualTo(userIdsBeforeIntent);
+                .that(mUserManagerState.getUserIds())
+                .isEqualTo(userIdsBeforeIntent);
         assertWithMessage(
-                "Unexpected changes to canForwardToProfileIdMap on receiving intent: " + action)
-                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent)).isEqualTo(
-                        canForwardToProfileIdMapBeforeIntent);
+                        "Unexpected changes to canForwardToProfileIdMap on receiving intent: "
+                                + action)
+                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent))
+                .isEqualTo(canForwardToProfileIdMapBeforeIntent);
     }
 
     @Test
@@ -633,18 +657,20 @@ public class UserManagerStateTest {
         UserId currentUser = UserId.of(mSystemUser);
         UserId managedUser = UserId.of(mManagedUser);
         UserId privateUser = UserId.of(mPrivateUser);
-        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfo1, mMockInfo2);
-        when(mMockPackageManager.queryIntentActivitiesAsUser(mMockIntent,
-                PackageManager.MATCH_DEFAULT_ONLY, mSystemUser)).thenReturn(
-                mMockResolveInfoList);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
-
-        // UserManagerState#mUserId and UserManagerState#mCanForwardToProfileIdMap will empty
+        final List<ResolveInfo> mMockResolveInfoList =
+                Lists.newArrayList(mMockInfoManagedUser, mMockInfoPrivateUser);
+        when(mMockPackageManager.queryIntentActivitiesAsUser(
+                        mMockIntent, PackageManager.MATCH_DEFAULT_ONLY, mSystemUser))
+                .thenReturn(mMockResolveInfoList);
+        initializeUserManagerState(
+                currentUser, Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
+
+        // UserManagerState#mUserId and UserManagerState#mCanForwardToProfileIdMap will
+        // empty
         // by default if the getters of these member variables have not been called
         List<UserId> userIdsBeforeIntent = new ArrayList<>(mUserManagerState.getUserIds());
-        Map<UserId, Boolean> canForwardToProfileIdMapBeforeIntent = new HashMap<>(
-                mUserManagerState.getCanForwardToProfileIdMap(mMockIntent));
+        Map<UserId, Boolean> canForwardToProfileIdMapBeforeIntent =
+                new HashMap<>(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent));
 
         List<UserId> expectedUserIdsAfterIntent = Lists.newArrayList(currentUser, managedUser);
 
@@ -652,14 +678,18 @@ public class UserManagerStateTest {
         mUserManagerState.onProfileActionStatusChange(action, privateUser);
 
         assertWithMessage(
-                "UserIds list should not be same before and after receiving intent: " + action)
-                .that(mUserManagerState.getUserIds()).isNotEqualTo(userIdsBeforeIntent);
+                        "UserIds list should not be same before and after receiving intent: "
+                                + action)
+                .that(mUserManagerState.getUserIds())
+                .isNotEqualTo(userIdsBeforeIntent);
         assertWithMessage("Unexpected changes to user id list on receiving intent: " + action)
-                .that(mUserManagerState.getUserIds()).isEqualTo(expectedUserIdsAfterIntent);
-        assertWithMessage("CanForwardToLabelMap should be same before and after receiving intent: "
-                + action)
-                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent)).isEqualTo(
-                        canForwardToProfileIdMapBeforeIntent);
+                .that(mUserManagerState.getUserIds())
+                .isEqualTo(expectedUserIdsAfterIntent);
+        assertWithMessage(
+                        "CanForwardToLabelMap should be same before and after receiving intent: "
+                                + action)
+                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent))
+                .isEqualTo(canForwardToProfileIdMapBeforeIntent);
     }
 
     @Test
@@ -668,40 +698,84 @@ public class UserManagerStateTest {
         UserId currentUser = UserId.of(mSystemUser);
         UserId managedUser = UserId.of(mManagedUser);
         UserId privateUser = UserId.of(mPrivateUser);
-        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfo1, mMockInfo2);
-        when(mMockPackageManager.queryIntentActivitiesAsUser(mMockIntent,
-                PackageManager.MATCH_DEFAULT_ONLY, mSystemUser)).thenReturn(
-                mMockResolveInfoList);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
+        final List<ResolveInfo> mMockResolveInfoList =
+                Lists.newArrayList(mMockInfoManagedUser, mMockInfoPrivateUser);
+        when(mMockPackageManager.queryIntentActivitiesAsUser(
+                        mMockIntent, PackageManager.MATCH_DEFAULT_ONLY, mSystemUser))
+                .thenReturn(mMockResolveInfoList);
+        initializeUserManagerState(
+                currentUser, Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
 
         // initialising the userIds list and canForwardToProfileIdMap
         mUserManagerState.getUserIds();
         mUserManagerState.getCanForwardToProfileIdMap(mMockIntent);
 
         // Making the private profile unavailable after it has been initialised
-        mUserManagerState.onProfileActionStatusChange(Intent.ACTION_PROFILE_UNAVAILABLE,
-                privateUser);
+        mUserManagerState.onProfileActionStatusChange(
+                Intent.ACTION_PROFILE_UNAVAILABLE, privateUser);
 
         List<UserId> userIdsBeforeIntent = new ArrayList<>(mUserManagerState.getUserIds());
-        Map<UserId, Boolean> canForwardToProfileIdMapBeforeIntent = new HashMap<>(
-                mUserManagerState.getCanForwardToProfileIdMap(mMockIntent));
+        Map<UserId, Boolean> canForwardToProfileIdMapBeforeIntent =
+                new HashMap<>(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent));
 
-        List<UserId> expectedUserIdsAfterIntent = Lists.newArrayList(currentUser, managedUser,
-                privateUser);
+        List<UserId> expectedUserIdsAfterIntent =
+                Lists.newArrayList(currentUser, managedUser, privateUser);
 
         String action = Intent.ACTION_PROFILE_AVAILABLE;
         mUserManagerState.onProfileActionStatusChange(action, privateUser);
 
         assertWithMessage(
-                "UserIds list should not be same before and after receiving intent: " + action)
-                .that(mUserManagerState.getUserIds()).isNotEqualTo(userIdsBeforeIntent);
+                        "UserIds list should not be same before and after receiving intent: "
+                                + action)
+                .that(mUserManagerState.getUserIds())
+                .isNotEqualTo(userIdsBeforeIntent);
         assertWithMessage("Unexpected changes to user id list on receiving intent: " + action)
-                .that(mUserManagerState.getUserIds()).isEqualTo(expectedUserIdsAfterIntent);
-        assertWithMessage("CanForwardToLabelMap should be same before and after receiving intent: "
-                + action)
-                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent)).isEqualTo(
-                        canForwardToProfileIdMapBeforeIntent);
+                .that(mUserManagerState.getUserIds())
+                .isEqualTo(expectedUserIdsAfterIntent);
+        assertWithMessage(
+                        "CanForwardToLabelMap should be same before and after receiving intent: "
+                                + action)
+                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent))
+                .isEqualTo(canForwardToProfileIdMapBeforeIntent);
+    }
+
+    @Test
+    public void testOnProfileStatusChange_actionProfileAdded() {
+        assumeTrue(SdkLevel.isAtLeastV());
+        UserId currentUser = UserId.of(mSystemUser);
+        UserId managedUser = UserId.of(mManagedUser);
+        UserId privateUser = UserId.of(mPrivateUser);
+
+        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfoManagedUser);
+
+        when(mMockPackageManager.queryIntentActivities(any(Intent.class), anyInt()))
+                .thenReturn(mMockResolveInfoList);
+
+        initializeUserManagerState(currentUser, Lists.newArrayList(mSystemUser, mManagedUser));
+
+        mUserManagerState.setCurrentStateIntent(new Intent());
+
+        // initialising the userIds list and canForwardToProfileIdMap
+        mUserManagerState.getUserIds();
+        mUserManagerState.getCanForwardToProfileIdMap(mMockIntent);
+
+        String action = Intent.ACTION_PROFILE_ADDED;
+        mUserManagerState.onProfileActionStatusChange(action, privateUser);
+
+        assertWithMessage(
+                        "UserIds list should not be same before and after receiving intent: "
+                                + action)
+                .that(mUserManagerState.getUserIds())
+                .containsExactly(currentUser, managedUser, privateUser);
+        assertWithMessage(
+                        "CanForwardToLabelMap should be same before and after receiving intent: "
+                                + action)
+                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent))
+                .isEqualTo(
+                        Map.ofEntries(
+                                Map.entry(currentUser, true),
+                                Map.entry(managedUser, true),
+                                Map.entry(privateUser, true)));
     }
 
     @Test
@@ -710,24 +784,27 @@ public class UserManagerStateTest {
         UserId currentUser = UserId.of(mSystemUser);
         UserId managedUser = UserId.of(mManagedUser);
         UserId privateUser = UserId.of(mPrivateUser);
-        final List<ResolveInfo> mMockResolveInfoList = Lists.newArrayList(mMockInfo1, mMockInfo2);
-        when(mMockPackageManager.queryIntentActivitiesAsUser(mMockIntent,
-                PackageManager.MATCH_DEFAULT_ONLY, mSystemUser)).thenReturn(
-                mMockResolveInfoList);
+        final List<ResolveInfo> mMockResolveInfoList =
+                Lists.newArrayList(mMockInfoManagedUser, mMockInfoPrivateUser);
+        when(mMockPackageManager.queryIntentActivities(any(Intent.class), anyInt()))
+                .thenReturn(mMockResolveInfoList);
+
+        when(mMockUserManager.getProfileParent(UserHandle.of(privateUser.getIdentifier())))
+                .thenReturn(mPrimaryUser);
 
         // Private user will not be initialised if it is in quiet mode
         when(mMockUserManager.isQuietModeEnabled(mPrivateUser)).thenReturn(true);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
-
-        // UserManagerState#mUserId and UserManagerState#mCanForwardToProfileIdMap will be empty
-        // by default if the getters of these member variables have not been called
+        initializeUserManagerState(
+                currentUser, Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
+        mUserManagerState.setCurrentStateIntent(new Intent());
+        // UserManagerState#mUserId and UserManagerState#mCanForwardToProfileIdMap will
+        // be empty by default if the getters of these member variables have not been called
         List<UserId> userIdsBeforeIntent = new ArrayList<>(mUserManagerState.getUserIds());
-        Map<UserId, Boolean> canForwardToProfileIdMapBeforeIntent = new HashMap<>(
-                mUserManagerState.getCanForwardToProfileIdMap(mMockIntent));
+        Map<UserId, Boolean> canForwardToProfileIdMapBeforeIntent =
+                new HashMap<>(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent));
 
-        List<UserId> expectedUserIdsAfterIntent = Lists.newArrayList(currentUser, managedUser,
-                privateUser);
+        List<UserId> expectedUserIdsAfterIntent =
+                Lists.newArrayList(currentUser, managedUser, privateUser);
         Map<UserId, Boolean> expectedCanForwardToProfileIdMapAfterIntent = new HashMap<>();
         expectedCanForwardToProfileIdMapAfterIntent.put(currentUser, true);
         expectedCanForwardToProfileIdMapAfterIntent.put(managedUser, true);
@@ -737,56 +814,62 @@ public class UserManagerStateTest {
         mUserManagerState.onProfileActionStatusChange(action, privateUser);
 
         assertWithMessage(
-                "UserIds list should not be same before and after receiving intent: " + action)
-                .that(mUserManagerState.getUserIds()).isNotEqualTo(userIdsBeforeIntent);
+                        "UserIds list should not be same before and after receiving intent: "
+                                + action)
+                .that(mUserManagerState.getUserIds())
+                .isNotEqualTo(userIdsBeforeIntent);
         assertWithMessage("Unexpected changes to user id list on receiving intent: " + action)
-                .that(mUserManagerState.getUserIds()).isEqualTo(expectedUserIdsAfterIntent);
+                .that(mUserManagerState.getUserIds())
+                .isEqualTo(expectedUserIdsAfterIntent);
         assertWithMessage(
-                "CanForwardToLabelMap should not be same before and after receiving intent: "
-                        + action)
-                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent)).isNotEqualTo(
-                        canForwardToProfileIdMapBeforeIntent);
+                        "CanForwardToLabelMap should not be same before and after receiving intent:"
+                                + " "
+                                + action)
+                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent))
+                .isNotEqualTo(canForwardToProfileIdMapBeforeIntent);
         assertWithMessage(
-                "Unexpected changes to canForwardToProfileIdMap on receiving intent: " + action)
-                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent)).isEqualTo(
-                        expectedCanForwardToProfileIdMapAfterIntent);
+                        "Unexpected changes to canForwardToProfileIdMap on receiving intent: "
+                                + action)
+                .that(mUserManagerState.getCanForwardToProfileIdMap(mMockIntent))
+                .isEqualTo(expectedCanForwardToProfileIdMapAfterIntent);
     }
 
     @Test
     public void testGetUserIdToLabelMap_systemUserAndManagedUser_PreV() {
         if (SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mSystemUser);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser));
+        initializeUserManagerState(currentUser, Lists.newArrayList(mSystemUser, mManagedUser));
         if (SdkLevel.isAtLeastT()) {
-            DevicePolicyResourcesManager devicePolicyResourcesManager = mock(
-                    DevicePolicyResourcesManager.class);
+            DevicePolicyResourcesManager devicePolicyResourcesManager =
+                    mock(DevicePolicyResourcesManager.class);
             when(mDevicePolicyManager.getResources()).thenReturn(devicePolicyResourcesManager);
-            when(devicePolicyResourcesManager.getString(eq(PERSONAL_TAB), any())).thenReturn(
-                    PERSONAL);
+            when(devicePolicyResourcesManager.getString(eq(PERSONAL_TAB), any()))
+                    .thenReturn(PERSONAL);
             when(devicePolicyResourcesManager.getString(eq(WORK_TAB), any())).thenReturn(WORK);
         }
 
         Map<UserId, String> userIdToLabelMap = mUserManagerState.getUserIdToLabelMap();
 
         assertWithMessage("Incorrect label returned for user id " + mSystemUser)
-                .that(userIdToLabelMap.get(UserId.of(mSystemUser))).isEqualTo(PERSONAL);
+                .that(userIdToLabelMap.get(UserId.of(mSystemUser)))
+                .isEqualTo(PERSONAL);
         assertWithMessage("Incorrect label returned for user id " + mManagedUser)
-                .that(userIdToLabelMap.get(UserId.of(mManagedUser))).isEqualTo(WORK);
+                .that(userIdToLabelMap.get(UserId.of(mManagedUser)))
+                .isEqualTo(WORK);
     }
 
     @Test
     public void testGetUserIdToLabelMap_systemUserManagedUserPrivateUser_PostV() {
         if (!SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mSystemUser);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
+        initializeUserManagerState(
+                currentUser, Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
         if (SdkLevel.isAtLeastT()) {
-            DevicePolicyResourcesManager devicePolicyResourcesManager = mock(
-                    DevicePolicyResourcesManager.class);
+            DevicePolicyResourcesManager devicePolicyResourcesManager =
+                    mock(DevicePolicyResourcesManager.class);
             when(mDevicePolicyManager.getResources()).thenReturn(devicePolicyResourcesManager);
-            when(devicePolicyResourcesManager.getString(eq(PERSONAL_TAB), any())).thenReturn(
-                    PERSONAL);
+            when(devicePolicyResourcesManager.getString(eq(PERSONAL_TAB), any()))
+                    .thenReturn(PERSONAL);
         }
         UserManager managedUserManager = getUserManagerForManagedUser();
         UserManager privateUserManager = getUserManagerForPrivateUser();
@@ -796,45 +879,50 @@ public class UserManagerStateTest {
         Map<UserId, String> userIdToLabelMap = mUserManagerState.getUserIdToLabelMap();
 
         assertWithMessage("Incorrect label returned for user id " + mSystemUser)
-                .that(userIdToLabelMap.get(UserId.of(mSystemUser))).isEqualTo(PERSONAL);
+                .that(userIdToLabelMap.get(UserId.of(mSystemUser)))
+                .isEqualTo(PERSONAL);
         assertWithMessage("Incorrect label returned for user id " + mManagedUser)
-                .that(userIdToLabelMap.get(UserId.of(mManagedUser))).isEqualTo(WORK);
+                .that(userIdToLabelMap.get(UserId.of(mManagedUser)))
+                .isEqualTo(WORK);
         assertWithMessage("Incorrect label returned for user id " + mPrivateUser)
-                .that(userIdToLabelMap.get(UserId.of(mPrivateUser))).isEqualTo(PRIVATE);
+                .that(userIdToLabelMap.get(UserId.of(mPrivateUser)))
+                .isEqualTo(PRIVATE);
     }
 
     @Test
     public void testGetUserIdToBadgeMap_systemUserManagedUser_PreV() {
         if (SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mSystemUser);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser));
+        initializeUserManagerState(currentUser, Lists.newArrayList(mSystemUser, mManagedUser));
         Drawable workBadge = mock(Drawable.class);
         Resources resources = mock(Resources.class);
         when(mMockContext.getResources()).thenReturn(resources);
         when(mMockContext.getDrawable(R.drawable.ic_briefcase)).thenReturn(workBadge);
         if (SdkLevel.isAtLeastT()) {
-            DevicePolicyResourcesManager devicePolicyResourcesManager = mock(
-                    DevicePolicyResourcesManager.class);
+            DevicePolicyResourcesManager devicePolicyResourcesManager =
+                    mock(DevicePolicyResourcesManager.class);
             when(mDevicePolicyManager.getResources()).thenReturn(devicePolicyResourcesManager);
-            when(devicePolicyResourcesManager.getDrawable(eq(WORK_PROFILE_ICON), eq(SOLID_COLORED),
-                    any())).thenReturn(workBadge);
+            when(devicePolicyResourcesManager.getDrawable(
+                            eq(WORK_PROFILE_ICON), eq(SOLID_COLORED), any()))
+                    .thenReturn(workBadge);
         }
 
         Map<UserId, Drawable> userIdToBadgeMap = mUserManagerState.getUserIdToBadgeMap();
 
         assertWithMessage("There should be no badge present for personal user")
-                .that(userIdToBadgeMap.containsKey(UserId.of(mSystemUser))).isFalse();
+                .that(userIdToBadgeMap.containsKey(UserId.of(mSystemUser)))
+                .isFalse();
         assertWithMessage("Incorrect badge returned for user id " + mManagedUser)
-                .that(userIdToBadgeMap.get(UserId.of(mManagedUser))).isEqualTo(workBadge);
+                .that(userIdToBadgeMap.get(UserId.of(mManagedUser)))
+                .isEqualTo(workBadge);
     }
 
     @Test
     public void testGetUserIdToBadgeMap_systemUserManagedUserPrivateUser_PostV() {
         if (!SdkLevel.isAtLeastV()) return;
         UserId currentUser = UserId.of(mSystemUser);
-        initializeUserManagerState(currentUser,
-                Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
+        initializeUserManagerState(
+                currentUser, Lists.newArrayList(mSystemUser, mManagedUser, mPrivateUser));
         Drawable workBadge = mock(Drawable.class);
         Drawable privateBadge = mock(Drawable.class);
         UserManager managedUserManager = getUserManagerForManagedUser();
@@ -845,19 +933,23 @@ public class UserManagerStateTest {
         Map<UserId, Drawable> userIdToBadgeMap = mUserManagerState.getUserIdToBadgeMap();
 
         assertWithMessage("There should be no badge present for personal user")
-                .that(userIdToBadgeMap.get(UserId.of(mSystemUser))).isNull();
+                .that(userIdToBadgeMap.get(UserId.of(mSystemUser)))
+                .isNull();
         assertWithMessage("Incorrect badge returned for user id " + mManagedUser)
-                .that(userIdToBadgeMap.get(UserId.of(mManagedUser))).isEqualTo(workBadge);
+                .that(userIdToBadgeMap.get(UserId.of(mManagedUser)))
+                .isEqualTo(workBadge);
         assertWithMessage("Incorrect badge returned for user id " + mPrivateUser)
-                .that(userIdToBadgeMap.get(UserId.of(mPrivateUser))).isEqualTo(privateBadge);
+                .that(userIdToBadgeMap.get(UserId.of(mPrivateUser)))
+                .isEqualTo(privateBadge);
     }
 
     private void initializeUserManagerState(UserId current, List<UserHandle> usersOnDevice) {
         when(mMockUserManager.getUserProfiles()).thenReturn(usersOnDevice);
         TestConfigStore testConfigStore = new TestConfigStore();
         testConfigStore.enablePrivateSpaceInPhotoPicker();
-        mUserManagerState = new UserManagerState.RuntimeUserManagerState(mMockContext, current,
-                true, testConfigStore);
+        mUserManagerState =
+                new UserManagerState.RuntimeUserManagerState(
+                        mMockContext, current, true, testConfigStore);
     }
 
     private UserManager getUserManagerForManagedUser() {