Home | History | Annotate | Download | only in pm
      1 /*
      2  * Copyright (C) 2011 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.server.pm;
     18 
     19 import android.content.BroadcastReceiver;
     20 import android.content.Context;
     21 import android.content.Intent;
     22 import android.content.IntentFilter;
     23 import android.content.pm.UserInfo;
     24 import android.os.Bundle;
     25 import android.os.UserHandle;
     26 import android.os.UserManager;
     27 import android.test.AndroidTestCase;
     28 
     29 import com.android.internal.util.ArrayUtils;
     30 
     31 import java.util.ArrayList;
     32 import java.util.Arrays;
     33 import java.util.List;
     34 
     35 /** Test {@link UserManager} functionality. */
     36 public class UserManagerTest extends AndroidTestCase {
     37     private static final int REMOVE_CHECK_INTERVAL = 500;
     38     private static final int REMOVE_TIMEOUT = 60 * 1000;
     39     private UserManager mUserManager = null;
     40     private final Object mUserLock = new Object();
     41     private List<Integer> usersToRemove;
     42 
     43     @Override
     44     public void setUp() throws Exception {
     45         super.setUp();
     46         mUserManager = UserManager.get(getContext());
     47         IntentFilter filter = new IntentFilter(Intent.ACTION_USER_REMOVED);
     48         getContext().registerReceiver(new BroadcastReceiver() {
     49             @Override
     50             public void onReceive(Context context, Intent intent) {
     51                 synchronized (mUserLock) {
     52                     mUserLock.notifyAll();
     53                 }
     54             }
     55         }, filter);
     56 
     57         removeExistingUsers();
     58         usersToRemove = new ArrayList<>();
     59     }
     60 
     61     @Override
     62     protected void tearDown() throws Exception {
     63         for (Integer userId : usersToRemove) {
     64             removeUser(userId);
     65         }
     66         super.tearDown();
     67     }
     68 
     69     private void removeExistingUsers() {
     70         List<UserInfo> list = mUserManager.getUsers();
     71         for (UserInfo user : list) {
     72             // Keep system and primary user.
     73             // We do not have to keep primary user, but in split system user mode, we need it
     74             // until http://b/22976637 is fixed.  Right now in split system user mode, you need to
     75             // switch to primary user and run tests under primary user.
     76             if (user.id != UserHandle.USER_SYSTEM && !user.isPrimary()) {
     77                 removeUser(user.id);
     78             }
     79         }
     80     }
     81 
     82     public void testHasSystemUser() throws Exception {
     83         assertTrue(findUser(UserHandle.USER_SYSTEM));
     84     }
     85 
     86     public void testAddUser() throws Exception {
     87         UserInfo userInfo = createUser("Guest 1", UserInfo.FLAG_GUEST);
     88         assertTrue(userInfo != null);
     89 
     90         List<UserInfo> list = mUserManager.getUsers();
     91         boolean found = false;
     92         for (UserInfo user : list) {
     93             if (user.id == userInfo.id && user.name.equals("Guest 1")
     94                     && user.isGuest()
     95                     && !user.isAdmin()
     96                     && !user.isPrimary()) {
     97                 found = true;
     98                 Bundle restrictions = mUserManager.getUserRestrictions(user.getUserHandle());
     99                 assertFalse("New user should have DISALLOW_CONFIG_WIFI =false by default",
    100                         restrictions.getBoolean(UserManager.DISALLOW_CONFIG_WIFI));
    101             }
    102         }
    103         assertTrue(found);
    104     }
    105 
    106     public void testAdd2Users() throws Exception {
    107         UserInfo user1 = createUser("Guest 1", UserInfo.FLAG_GUEST);
    108         UserInfo user2 = createUser("User 2", UserInfo.FLAG_ADMIN);
    109 
    110         assertTrue(user1 != null);
    111         assertTrue(user2 != null);
    112 
    113         assertTrue(findUser(0));
    114         assertTrue(findUser(user1.id));
    115         assertTrue(findUser(user2.id));
    116     }
    117 
    118     public void testRemoveUser() throws Exception {
    119         UserInfo userInfo = createUser("Guest 1", UserInfo.FLAG_GUEST);
    120         removeUser(userInfo.id);
    121 
    122         assertFalse(findUser(userInfo.id));
    123     }
    124 
    125     public void testAddGuest() throws Exception {
    126         UserInfo userInfo1 = createUser("Guest 1", UserInfo.FLAG_GUEST);
    127         UserInfo userInfo2 = createUser("Guest 2", UserInfo.FLAG_GUEST);
    128         assertNotNull(userInfo1);
    129         assertNull(userInfo2);
    130     }
    131 
    132     // Make sure only one managed profile can be created
    133     public void testAddManagedProfile() throws Exception {
    134         final int primaryUserId = mUserManager.getPrimaryUser().id;
    135         UserInfo userInfo1 = createProfileForUser("Managed 1",
    136                 UserInfo.FLAG_MANAGED_PROFILE, primaryUserId);
    137         UserInfo userInfo2 = createProfileForUser("Managed 2",
    138                 UserInfo.FLAG_MANAGED_PROFILE, primaryUserId);
    139         assertNotNull(userInfo1);
    140         assertNull(userInfo2);
    141         // Verify that current user is not a managed profile
    142         assertFalse(mUserManager.isManagedProfile());
    143     }
    144 
    145     public void testGetUserCreationTime() throws Exception {
    146         final int primaryUserId = mUserManager.getPrimaryUser().id;
    147         UserInfo profile = createProfileForUser("Managed 1",
    148                 UserInfo.FLAG_MANAGED_PROFILE, primaryUserId);
    149         assertNotNull(profile);
    150         assertTrue("creationTime must be set when the profile is created",
    151                 profile.creationTime > 0);
    152         assertEquals(profile.creationTime, mUserManager.getUserCreationTime(
    153                 new UserHandle(profile.id)));
    154 
    155         long ownerCreationTime = mUserManager.getUserInfo(primaryUserId).creationTime;
    156         assertEquals(ownerCreationTime, mUserManager.getUserCreationTime(
    157                 new UserHandle(primaryUserId)));
    158 
    159         try {
    160             int noSuchUserId = 100500;
    161             mUserManager.getUserCreationTime(new UserHandle(noSuchUserId));
    162             fail("SecurityException should be thrown for nonexistent user");
    163         } catch (Exception e) {
    164             assertTrue("SecurityException should be thrown for nonexistent user, but was: " + e,
    165                     e instanceof SecurityException);
    166         }
    167 
    168         UserInfo user = createUser("User 1", 0);
    169         try {
    170             mUserManager.getUserCreationTime(new UserHandle(user.id));
    171             fail("SecurityException should be thrown for other user");
    172         } catch (Exception e) {
    173             assertTrue("SecurityException should be thrown for other user, but was: " + e,
    174                     e instanceof SecurityException);
    175         }
    176     }
    177 
    178 
    179     private boolean findUser(int id) {
    180         List<UserInfo> list = mUserManager.getUsers();
    181 
    182         for (UserInfo user : list) {
    183             if (user.id == id) {
    184                 return true;
    185             }
    186         }
    187         return false;
    188     }
    189 
    190     public void testSerialNumber() {
    191         UserInfo user1 = createUser("User 1", 0);
    192         int serialNumber1 = user1.serialNumber;
    193         assertEquals(serialNumber1, mUserManager.getUserSerialNumber(user1.id));
    194         assertEquals(user1.id, mUserManager.getUserHandle(serialNumber1));
    195         UserInfo user2 = createUser("User 2", 0);
    196         int serialNumber2 = user2.serialNumber;
    197         assertFalse(serialNumber1 == serialNumber2);
    198         assertEquals(serialNumber2, mUserManager.getUserSerialNumber(user2.id));
    199         assertEquals(user2.id, mUserManager.getUserHandle(serialNumber2));
    200     }
    201 
    202     public void testGetSerialNumbersOfUsers() {
    203         UserInfo user1 = createUser("User 1", 0);
    204         UserInfo user2 = createUser("User 2", 0);
    205         long[] serialNumbersOfUsers = mUserManager.getSerialNumbersOfUsers(false);
    206         String errMsg = "Array " + Arrays.toString(serialNumbersOfUsers) + " should contain ";
    207         assertTrue(errMsg + user1.serialNumber,
    208                 ArrayUtils.contains(serialNumbersOfUsers, user1.serialNumber));
    209         assertTrue(errMsg + user2.serialNumber,
    210                 ArrayUtils.contains(serialNumbersOfUsers, user2.serialNumber));
    211     }
    212 
    213     public void testMaxUsers() {
    214         int N = UserManager.getMaxSupportedUsers();
    215         int count = mUserManager.getUsers().size();
    216         // Create as many users as permitted and make sure creation passes
    217         while (count < N) {
    218             UserInfo ui = createUser("User " + count, 0);
    219             assertNotNull(ui);
    220             count++;
    221         }
    222         // Try to create one more user and make sure it fails
    223         UserInfo extra = createUser("One more", 0);
    224         assertNull(extra);
    225     }
    226 
    227     public void testRestrictions() {
    228         UserInfo testUser = createUser("User 1", 0);
    229 
    230         mUserManager.setUserRestriction(
    231                 UserManager.DISALLOW_INSTALL_APPS, true, new UserHandle(testUser.id));
    232         mUserManager.setUserRestriction(
    233                 UserManager.DISALLOW_CONFIG_WIFI, false, new UserHandle(testUser.id));
    234 
    235         Bundle stored = mUserManager.getUserRestrictions(new UserHandle(testUser.id));
    236         // Note this will fail if DO already sets those restrictions.
    237         assertEquals(stored.getBoolean(UserManager.DISALLOW_CONFIG_WIFI), false);
    238         assertEquals(stored.getBoolean(UserManager.DISALLOW_UNINSTALL_APPS), false);
    239         assertEquals(stored.getBoolean(UserManager.DISALLOW_INSTALL_APPS), true);
    240     }
    241 
    242     private void removeUser(int userId) {
    243         synchronized (mUserLock) {
    244             mUserManager.removeUser(userId);
    245             long time = System.currentTimeMillis();
    246             while (mUserManager.getUserInfo(userId) != null) {
    247                 try {
    248                     mUserLock.wait(REMOVE_CHECK_INTERVAL);
    249                 } catch (InterruptedException ie) {
    250                     Thread.currentThread().interrupt();
    251                     return;
    252                 }
    253                 if (System.currentTimeMillis() - time > REMOVE_TIMEOUT) {
    254                     fail("Timeout waiting for removeUser. userId = " + userId);
    255                 }
    256             }
    257         }
    258     }
    259 
    260     private UserInfo createUser(String name, int flags) {
    261         UserInfo user = mUserManager.createUser(name, flags);
    262         if (user != null) {
    263             usersToRemove.add(user.id);
    264         }
    265         return user;
    266     }
    267 
    268     private UserInfo createProfileForUser(String name, int flags, int userHandle) {
    269         UserInfo profile = mUserManager.createProfileForUser(name, flags, userHandle);
    270         if (profile != null) {
    271             usersToRemove.add(profile.id);
    272         }
    273         return profile;
    274     }
    275 
    276 }
    277