services/tests/servicestests/src/com/android/server/pm/UserManagerTest.java

   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 }