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