UserManagerTest.java revision 66f73a87b132c9f9ec04e685e361e11de05ef65b 
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
17package com.android.server.pm;
18
19import android.content.BroadcastReceiver;
20import android.content.Context;
21import android.content.Intent;
22import android.content.IntentFilter;
23import android.content.pm.UserInfo;
24import android.app.ActivityManager;
25import android.os.Bundle;
26import android.os.UserHandle;
27import android.os.UserManager;
28import android.provider.Settings;
29import android.test.AndroidTestCase;
30import android.test.suitebuilder.annotation.LargeTest;
31import android.test.suitebuilder.annotation.MediumTest;
32import android.test.suitebuilder.annotation.SmallTest;
33
34import com.android.internal.util.ArrayUtils;
35
36import java.util.ArrayList;
37import java.util.Arrays;
38import java.util.List;
39
40/** Test {@link UserManager} functionality. */
41public class UserManagerTest extends AndroidTestCase {
42    private static final int REMOVE_CHECK_INTERVAL_MILLIS = 500; // 0.5 seconds
43    private static final int REMOVE_TIMEOUT_MILLIS = 60 * 1000; // 60 seconds
44    private static final int SWITCH_USER_TIMEOUT_MILLIS = 40 * 1000; // 40 seconds
45
46    private final Object mUserRemoveLock = new Object();
47    private final Object mUserSwitchLock = new Object();
48
49    private UserManager mUserManager = null;
50    private List<Integer> usersToRemove;
51
52    @Override
53    public void setUp() throws Exception {
54        super.setUp();
55        mUserManager = UserManager.get(getContext());
56
57        IntentFilter filter = new IntentFilter(Intent.ACTION_USER_REMOVED);
58        filter.addAction(Intent.ACTION_USER_SWITCHED);
59        getContext().registerReceiver(new BroadcastReceiver() {
60            @Override
61            public void onReceive(Context context, Intent intent) {
62                switch (intent.getAction()) {
63                    case Intent.ACTION_USER_REMOVED:
64                        synchronized (mUserRemoveLock) {
65                            mUserRemoveLock.notifyAll();
66                        }
67                        break;
68                    case Intent.ACTION_USER_SWITCHED:
69                        synchronized (mUserSwitchLock) {
70                            mUserSwitchLock.notifyAll();
71                        }
72                        break;
73                }
74            }
75        }, filter);
76
77        removeExistingUsers();
78        usersToRemove = new ArrayList<>();
79    }
80
81    @Override
82    protected void tearDown() throws Exception {
83        for (Integer userId : usersToRemove) {
84            removeUser(userId);
85        }
86        super.tearDown();
87    }
88
89    private void removeExistingUsers() {
90        List<UserInfo> list = mUserManager.getUsers();
91        for (UserInfo user : list) {
92            // Keep system and primary user.
93            // We do not have to keep primary user, but in split system user mode, we need it
94            // until http://b/22976637 is fixed.  Right now in split system user mode, you need to
95            // switch to primary user and run tests under primary user.
96            if (user.id != UserHandle.USER_SYSTEM && !user.isPrimary()) {
97                removeUser(user.id);
98            }
99        }
100    }
101
102    @SmallTest
103    public void testHasSystemUser() throws Exception {
104        assertTrue(findUser(UserHandle.USER_SYSTEM));
105    }
106
107    @MediumTest
108    public void testAddUser() throws Exception {
109        UserInfo userInfo = createUser("Guest 1", UserInfo.FLAG_GUEST);
110        assertTrue(userInfo != null);
111
112        List<UserInfo> list = mUserManager.getUsers();
113        boolean found = false;
114        for (UserInfo user : list) {
115            if (user.id == userInfo.id && user.name.equals("Guest 1")
116                    && user.isGuest()
117                    && !user.isAdmin()
118                    && !user.isPrimary()) {
119                found = true;
120                Bundle restrictions = mUserManager.getUserRestrictions(user.getUserHandle());
121                assertTrue("Guest user should have DISALLOW_CONFIG_WIFI=true by default",
122                        restrictions.getBoolean(UserManager.DISALLOW_CONFIG_WIFI));
123            }
124        }
125        assertTrue(found);
126    }
127
128    @MediumTest
129    public void testAdd2Users() throws Exception {
130        UserInfo user1 = createUser("Guest 1", UserInfo.FLAG_GUEST);
131        UserInfo user2 = createUser("User 2", UserInfo.FLAG_ADMIN);
132
133        assertTrue(user1 != null);
134        assertTrue(user2 != null);
135
136        assertTrue(findUser(0));
137        assertTrue(findUser(user1.id));
138        assertTrue(findUser(user2.id));
139    }
140
141    @MediumTest
142    public void testRemoveUser() throws Exception {
143        UserInfo userInfo = createUser("Guest 1", UserInfo.FLAG_GUEST);
144        removeUser(userInfo.id);
145
146        assertFalse(findUser(userInfo.id));
147    }
148
149    @MediumTest
150    public void testAddGuest() throws Exception {
151        UserInfo userInfo1 = createUser("Guest 1", UserInfo.FLAG_GUEST);
152        UserInfo userInfo2 = createUser("Guest 2", UserInfo.FLAG_GUEST);
153        assertNotNull(userInfo1);
154        assertNull(userInfo2);
155    }
156
157    @MediumTest
158    public void testGetProfileParent() throws Exception {
159        final int primaryUserId = mUserManager.getPrimaryUser().id;
160
161        UserInfo userInfo = createProfileForUser("Profile",
162                UserInfo.FLAG_MANAGED_PROFILE, primaryUserId);
163        assertNotNull(userInfo);
164
165        UserInfo parentProfileInfo = mUserManager.getProfileParent(userInfo.id);
166        assertNotNull(parentProfileInfo);
167        assertEquals(parentProfileInfo.id, primaryUserId);
168    }
169
170    // Make sure only one managed profile can be created
171    @MediumTest
172    public void testAddManagedProfile() throws Exception {
173        final int primaryUserId = mUserManager.getPrimaryUser().id;
174        UserInfo userInfo1 = createProfileForUser("Managed 1",
175                UserInfo.FLAG_MANAGED_PROFILE, primaryUserId);
176        UserInfo userInfo2 = createProfileForUser("Managed 2",
177                UserInfo.FLAG_MANAGED_PROFILE, primaryUserId);
178
179        assertNotNull(userInfo1);
180        assertNull(userInfo2);
181        // Verify that current user is not a managed profile
182        assertFalse(mUserManager.isManagedProfile());
183    }
184
185    @MediumTest
186    public void testAddRestrictedProfile() throws Exception {
187        UserInfo userInfo = createRestrictedProfile("Profile");
188        assertNotNull(userInfo);
189
190        Bundle restrictions = mUserManager.getUserRestrictions(UserHandle.of(userInfo.id));
191        assertTrue("Restricted profile should have DISALLOW_MODIFY_ACCOUNTS restriction by default",
192                restrictions.getBoolean(UserManager.DISALLOW_MODIFY_ACCOUNTS));
193        assertTrue("Restricted profile should have DISALLOW_SHARE_LOCATION restriction by default",
194                restrictions.getBoolean(UserManager.DISALLOW_SHARE_LOCATION));
195
196        int locationMode = Settings.Secure.getIntForUser(getContext().getContentResolver(),
197                Settings.Secure.LOCATION_MODE,
198                Settings.Secure.LOCATION_MODE_HIGH_ACCURACY,
199                userInfo.id);
200        assertEquals("Restricted profile should have setting LOCATION_MODE set to "
201                + "LOCATION_MODE_OFF by default", locationMode, Settings.Secure.LOCATION_MODE_OFF);
202    }
203
204    @MediumTest
205    public void testGetUserCreationTime() throws Exception {
206        final int primaryUserId = mUserManager.getPrimaryUser().id;
207        UserInfo profile = createProfileForUser("Managed 1",
208                UserInfo.FLAG_MANAGED_PROFILE, primaryUserId);
209        assertNotNull(profile);
210        assertTrue("creationTime must be set when the profile is created",
211                profile.creationTime > 0);
212        assertEquals(profile.creationTime, mUserManager.getUserCreationTime(
213                new UserHandle(profile.id)));
214
215        long ownerCreationTime = mUserManager.getUserInfo(primaryUserId).creationTime;
216        assertEquals(ownerCreationTime, mUserManager.getUserCreationTime(
217                new UserHandle(primaryUserId)));
218
219        try {
220            int noSuchUserId = 100500;
221            mUserManager.getUserCreationTime(new UserHandle(noSuchUserId));
222            fail("SecurityException should be thrown for nonexistent user");
223        } catch (Exception e) {
224            assertTrue("SecurityException should be thrown for nonexistent user, but was: " + e,
225                    e instanceof SecurityException);
226        }
227
228        UserInfo user = createUser("User 1", 0);
229        try {
230            mUserManager.getUserCreationTime(new UserHandle(user.id));
231            fail("SecurityException should be thrown for other user");
232        } catch (Exception e) {
233            assertTrue("SecurityException should be thrown for other user, but was: " + e,
234                    e instanceof SecurityException);
235        }
236    }
237
238    private boolean findUser(int id) {
239        List<UserInfo> list = mUserManager.getUsers();
240
241        for (UserInfo user : list) {
242            if (user.id == id) {
243                return true;
244            }
245        }
246        return false;
247    }
248
249    @MediumTest
250    public void testSerialNumber() {
251        UserInfo user1 = createUser("User 1", 0);
252        int serialNumber1 = user1.serialNumber;
253        assertEquals(serialNumber1, mUserManager.getUserSerialNumber(user1.id));
254        assertEquals(user1.id, mUserManager.getUserHandle(serialNumber1));
255        UserInfo user2 = createUser("User 2", 0);
256        int serialNumber2 = user2.serialNumber;
257        assertFalse(serialNumber1 == serialNumber2);
258        assertEquals(serialNumber2, mUserManager.getUserSerialNumber(user2.id));
259        assertEquals(user2.id, mUserManager.getUserHandle(serialNumber2));
260    }
261
262    @MediumTest
263    public void testGetSerialNumbersOfUsers() {
264        UserInfo user1 = createUser("User 1", 0);
265        UserInfo user2 = createUser("User 2", 0);
266        long[] serialNumbersOfUsers = mUserManager.getSerialNumbersOfUsers(false);
267        String errMsg = "Array " + Arrays.toString(serialNumbersOfUsers) + " should contain ";
268        assertTrue(errMsg + user1.serialNumber,
269                ArrayUtils.contains(serialNumbersOfUsers, user1.serialNumber));
270        assertTrue(errMsg + user2.serialNumber,
271                ArrayUtils.contains(serialNumbersOfUsers, user2.serialNumber));
272    }
273
274    @MediumTest
275    public void testMaxUsers() {
276        int N = UserManager.getMaxSupportedUsers();
277        int count = mUserManager.getUsers().size();
278        // Create as many users as permitted and make sure creation passes
279        while (count < N) {
280            UserInfo ui = createUser("User " + count, 0);
281            assertNotNull(ui);
282            count++;
283        }
284        // Try to create one more user and make sure it fails
285        UserInfo extra = createUser("One more", 0);
286        assertNull(extra);
287    }
288
289    @MediumTest
290    public void testGetUserCount() {
291        int count = mUserManager.getUsers().size();
292        UserInfo user1 = createUser("User 1", 0);
293        assertNotNull(user1);
294        UserInfo user2 = createUser("User 2", 0);
295        assertNotNull(user2);
296        assertEquals(count + 2, mUserManager.getUserCount());
297    }
298
299    @MediumTest
300    public void testRestrictions() {
301        UserInfo testUser = createUser("User 1", 0);
302
303        mUserManager.setUserRestriction(
304                UserManager.DISALLOW_INSTALL_APPS, true, new UserHandle(testUser.id));
305        mUserManager.setUserRestriction(
306                UserManager.DISALLOW_CONFIG_WIFI, false, new UserHandle(testUser.id));
307
308        Bundle stored = mUserManager.getUserRestrictions(new UserHandle(testUser.id));
309        // Note this will fail if DO already sets those restrictions.
310        assertEquals(stored.getBoolean(UserManager.DISALLOW_CONFIG_WIFI), false);
311        assertEquals(stored.getBoolean(UserManager.DISALLOW_UNINSTALL_APPS), false);
312        assertEquals(stored.getBoolean(UserManager.DISALLOW_INSTALL_APPS), true);
313    }
314
315    @MediumTest
316    public void testSetDefaultGuestRestrictions() {
317        final Bundle origGuestRestrictions = mUserManager.getDefaultGuestRestrictions();
318        Bundle restrictions = new Bundle();
319        restrictions.putBoolean(UserManager.DISALLOW_FUN, true);
320        mUserManager.setDefaultGuestRestrictions(restrictions);
321
322        try {
323            UserInfo guest = createUser("Guest", UserInfo.FLAG_GUEST);
324            assertNotNull(guest);
325            assertTrue(mUserManager.hasUserRestriction(UserManager.DISALLOW_FUN,
326                    guest.getUserHandle()));
327        } finally {
328            mUserManager.setDefaultGuestRestrictions(origGuestRestrictions);
329        }
330    }
331
332    @LargeTest
333    public void testSwitchUser() {
334        ActivityManager am = getContext().getSystemService(ActivityManager.class);
335        final int startUser = am.getCurrentUser();
336        UserInfo user = createUser("User", 0);
337        assertNotNull(user);
338        // Switch to the user just created.
339        switchUser(user.id);
340        // Switch back to the starting user.
341        switchUser(startUser);
342    }
343
344    private void switchUser(int userId) {
345        synchronized (mUserSwitchLock) {
346            ActivityManager am = getContext().getSystemService(ActivityManager.class);
347            am.switchUser(userId);
348            long time = System.currentTimeMillis();
349            try {
350                mUserSwitchLock.wait(SWITCH_USER_TIMEOUT_MILLIS);
351            } catch (InterruptedException ie) {
352                Thread.currentThread().interrupt();
353                return;
354            }
355            if (System.currentTimeMillis() - time > SWITCH_USER_TIMEOUT_MILLIS) {
356                fail("Timeout waiting for the user switch to u" + userId);
357            }
358        }
359    }
360
361    private void removeUser(int userId) {
362        synchronized (mUserRemoveLock) {
363            mUserManager.removeUser(userId);
364            long time = System.currentTimeMillis();
365            while (mUserManager.getUserInfo(userId) != null) {
366                try {
367                    mUserRemoveLock.wait(REMOVE_CHECK_INTERVAL_MILLIS);
368                } catch (InterruptedException ie) {
369                    Thread.currentThread().interrupt();
370                    return;
371                }
372                if (System.currentTimeMillis() - time > REMOVE_TIMEOUT_MILLIS) {
373                    fail("Timeout waiting for removeUser. userId = " + userId);
374                }
375            }
376        }
377    }
378
379    private UserInfo createUser(String name, int flags) {
380        UserInfo user = mUserManager.createUser(name, flags);
381        if (user != null) {
382            usersToRemove.add(user.id);
383        }
384        return user;
385    }
386
387    private UserInfo createProfileForUser(String name, int flags, int userHandle) {
388        UserInfo profile = mUserManager.createProfileForUser(name, flags, userHandle);
389        if (profile != null) {
390            usersToRemove.add(profile.id);
391        }
392        return profile;
393    }
394
395    private UserInfo createRestrictedProfile(String name) {
396        UserInfo profile = mUserManager.createRestrictedProfile(name);
397        if (profile != null) {
398            usersToRemove.add(profile.id);
399        }
400        return profile;
401    }
402}
403