• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 package org.robolectric.shadows;
2 
3 import static android.os.Build.VERSION_CODES.M;
4 import static android.os.Build.VERSION_CODES.N;
5 import static android.os.Build.VERSION_CODES.N_MR1;
6 import static android.os.Build.VERSION_CODES.O;
7 import static android.os.Build.VERSION_CODES.Q;
8 import static android.os.Build.VERSION_CODES.R;
9 import static android.os.Build.VERSION_CODES.S;
10 import static android.os.Build.VERSION_CODES.TIRAMISU;
11 import static com.google.common.truth.Truth.assertThat;
12 import static org.junit.Assert.fail;
13 import static org.robolectric.Shadows.shadowOf;
14 
15 import android.Manifest.permission;
16 import android.app.Activity;
17 import android.app.Application;
18 import android.content.BroadcastReceiver;
19 import android.content.Context;
20 import android.content.Intent;
21 import android.content.IntentFilter;
22 import android.content.pm.PackageInfo;
23 import android.content.pm.UserInfo;
24 import android.graphics.Bitmap;
25 import android.os.Build;
26 import android.os.Bundle;
27 import android.os.Looper;
28 import android.os.Parcel;
29 import android.os.PersistableBundle;
30 import android.os.Process;
31 import android.os.UserHandle;
32 import android.os.UserManager;
33 import android.os.UserManager.EnforcingUser;
34 import androidx.test.core.app.ApplicationProvider;
35 import androidx.test.ext.junit.runners.AndroidJUnit4;
36 import java.util.List;
37 import java.util.concurrent.atomic.AtomicReference;
38 import org.junit.Before;
39 import org.junit.Test;
40 import org.junit.runner.RunWith;
41 import org.robolectric.Robolectric;
42 import org.robolectric.android.controller.ActivityController;
43 import org.robolectric.annotation.Config;
44 import org.robolectric.shadow.api.Shadow;
45 import org.robolectric.shadows.ShadowUserManager.UserState;
46 
47 @RunWith(AndroidJUnit4.class)
48 public class ShadowUserManagerTest {
49 
50   private UserManager userManager;
51   private Context context;
52 
53   private static final int TEST_USER_HANDLE = 0;
54   private static final int PROFILE_USER_HANDLE = 2;
55   private static final String PROFILE_USER_NAME = "profile";
56   private static final String SEED_ACCOUNT_NAME = "seed_account_name";
57   private static final String SEED_ACCOUNT_TYPE = "seed_account_type";
58   private static final int PROFILE_USER_FLAGS = 0;
59   private static final Bitmap TEST_USER_ICON = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
60 
61   @Before
setUp()62   public void setUp() {
63     context = ApplicationProvider.getApplicationContext();
64     userManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
65   }
66 
67   /**
68    * {@link ShadowUserManager} should support methods getting invoked when UserManager objects are
69    * returned from package contexts.
70    *
71    * <p>The root cause of this issue is that calling {@link Context#getApplicationContext()} returns
72    * null on a package context.
73    */
74   @Config(minSdk = R)
75   @Test
packageContextImpl_isUserOfType()76   public void packageContextImpl_isUserOfType() throws Exception {
77     Context packageContext =
78         context.createPackageContextAsUser(
79             context.getPackageName(), 0, UserHandle.of(/* userId= */ 0));
80     UserManager packageUserManager = packageContext.getSystemService(UserManager.class);
81     assertThat(packageUserManager.isUserOfType("sdfasdfsadf")).isFalse();
82   }
83 
84   @Test
shouldGetUserProfiles()85   public void shouldGetUserProfiles() {
86     assertThat(userManager.getUserProfiles()).contains(Process.myUserHandle());
87 
88     UserHandle anotherProfile = newUserHandle(2);
89     shadowOf(userManager).addUserProfile(anotherProfile);
90 
91     assertThat(userManager.getUserProfiles())
92         .containsExactly(Process.myUserHandle(), anotherProfile);
93   }
94 
95   @Test
getUserProfiles_calledFromProfile_shouldReturnList()96   public void getUserProfiles_calledFromProfile_shouldReturnList() {
97     ShadowProcess.setUid(2 * 100000);
98     assertThat(userManager.getUserProfiles()).contains(new UserHandle(2));
99 
100     shadowOf(userManager).addProfile(0, 2, "profile", /* profileFlags= */ 0);
101 
102     assertThat(userManager.getUserProfiles()).containsExactly(new UserHandle(0), new UserHandle(2));
103   }
104 
105   @Test
getUserProfiles_noProfiles_shouldReturnListOfSelf()106   public void getUserProfiles_noProfiles_shouldReturnListOfSelf() {
107     assertThat(userManager.getUserProfiles()).containsExactly(new UserHandle(0));
108   }
109 
110   @Test
testGetApplicationRestrictions()111   public void testGetApplicationRestrictions() {
112     String packageName = context.getPackageName();
113     assertThat(userManager.getApplicationRestrictions(packageName).size()).isEqualTo(0);
114 
115     Bundle restrictions = new Bundle();
116     restrictions.putCharSequence("test_key", "test_value");
117     shadowOf(userManager).setApplicationRestrictions(packageName, restrictions);
118 
119     assertThat(
120             userManager
121                 .getApplicationRestrictions(packageName)
122                 .getCharSequence("test_key")
123                 .toString())
124         .isEqualTo("test_value");
125   }
126 
127   @Test
128   @Config(minSdk = N)
isUserUnlocked()129   public void isUserUnlocked() {
130     assertThat(userManager.isUserUnlocked()).isTrue();
131     shadowOf(userManager).setUserUnlocked(false);
132     assertThat(userManager.isUserUnlocked()).isFalse();
133   }
134 
135   @Test
hasUserRestriction()136   public void hasUserRestriction() {
137     assertThat(userManager.hasUserRestriction(UserManager.ENSURE_VERIFY_APPS)).isFalse();
138 
139     UserHandle userHandle = Process.myUserHandle();
140     shadowOf(userManager).setUserRestriction(userHandle, UserManager.ENSURE_VERIFY_APPS, true);
141 
142     assertThat(userManager.hasUserRestriction(UserManager.ENSURE_VERIFY_APPS)).isTrue();
143   }
144 
145   @Test
setUserRestriction_forGivenUserHandle_setsTheRestriction()146   public void setUserRestriction_forGivenUserHandle_setsTheRestriction() {
147     assertThat(userManager.hasUserRestriction(UserManager.ENSURE_VERIFY_APPS)).isFalse();
148 
149     UserHandle userHandle = Process.myUserHandle();
150     shadowOf(userManager).setUserRestriction(UserManager.ENSURE_VERIFY_APPS, true, userHandle);
151 
152     assertThat(userManager.hasUserRestriction(UserManager.ENSURE_VERIFY_APPS)).isTrue();
153   }
154 
155   @Test
setUserRestriction_forCurrentUser_setsTheRestriction()156   public void setUserRestriction_forCurrentUser_setsTheRestriction() {
157     assertThat(userManager.hasUserRestriction(UserManager.ENSURE_VERIFY_APPS)).isFalse();
158 
159     userManager.setUserRestriction(UserManager.ENSURE_VERIFY_APPS, true);
160 
161     assertThat(userManager.hasUserRestriction(UserManager.ENSURE_VERIFY_APPS)).isTrue();
162   }
163 
164   @Test
getUserRestrictions()165   public void getUserRestrictions() {
166     assertThat(userManager.getUserRestrictions().size()).isEqualTo(0);
167 
168     UserHandle userHandle = Process.myUserHandle();
169     shadowOf(userManager).setUserRestriction(userHandle, UserManager.ENSURE_VERIFY_APPS, true);
170 
171     Bundle restrictions = userManager.getUserRestrictions();
172     assertThat(restrictions.size()).isEqualTo(1);
173     assertThat(restrictions.getBoolean(UserManager.ENSURE_VERIFY_APPS)).isTrue();
174 
175     // make sure that the bundle is not an internal state
176     restrictions.putBoolean("something", true);
177     restrictions = userManager.getUserRestrictions();
178     assertThat(restrictions.size()).isEqualTo(1);
179 
180     shadowOf(userManager).setUserRestriction(newUserHandle(10), UserManager.DISALLOW_CAMERA, true);
181 
182     assertThat(userManager.hasUserRestriction(UserManager.DISALLOW_CAMERA)).isFalse();
183   }
184 
185   @Test
clearUserRestrictions()186   public void clearUserRestrictions() {
187     assertThat(userManager.getUserRestrictions().size()).isEqualTo(0);
188     shadowOf(userManager)
189         .setUserRestriction(Process.myUserHandle(), UserManager.ENSURE_VERIFY_APPS, true);
190     assertThat(userManager.getUserRestrictions().size()).isEqualTo(1);
191 
192     shadowOf(userManager).clearUserRestrictions(Process.myUserHandle());
193     assertThat(userManager.getUserRestrictions().size()).isEqualTo(0);
194   }
195 
196   @Test
isManagedProfile()197   public void isManagedProfile() {
198     assertThat(userManager.isManagedProfile()).isFalse();
199     shadowOf(userManager).setManagedProfile(true);
200     assertThat(userManager.isManagedProfile()).isTrue();
201   }
202 
203   @Test
204   @Config(minSdk = R)
isManagedProfile_usesContextUser()205   public void isManagedProfile_usesContextUser() {
206     shadowOf(userManager)
207         .addProfile(
208             0, PROFILE_USER_HANDLE, PROFILE_USER_NAME, ShadowUserManager.FLAG_MANAGED_PROFILE);
209     assertThat(userManager.isManagedProfile()).isFalse();
210 
211     setUserIdInContext(PROFILE_USER_HANDLE);
212     assertThat(userManager.isManagedProfile()).isTrue();
213   }
214 
215   @Test
216   @Config(minSdk = N)
isManagedProfileWithHandle()217   public void isManagedProfileWithHandle() {
218     shadowOf(userManager).addUser(12, "secondary user", 0);
219     shadowOf(userManager)
220         .addProfile(12, 13, "another managed profile", ShadowUserManager.FLAG_MANAGED_PROFILE);
221     assertThat(userManager.isManagedProfile(13)).isTrue();
222   }
223 
224   @Test
225   @Config(minSdk = S)
isCloneProfile_withSetter()226   public void isCloneProfile_withSetter() {
227     shadowOf(userManager).setCloneProfile(false);
228     assertThat(userManager.isCloneProfile()).isFalse();
229 
230     shadowOf(userManager).setCloneProfile(true);
231     assertThat(userManager.isCloneProfile()).isTrue();
232   }
233 
234   @Test
235   @Config(minSdk = S)
isCloneProfile_usesContextUser()236   public void isCloneProfile_usesContextUser() {
237     assertThat(userManager.isCloneProfile()).isFalse();
238 
239     UserInfo profileUserInfo =
240         new UserInfo(
241             PROFILE_USER_HANDLE,
242             PROFILE_USER_NAME,
243             /* iconPath= */ null,
244             /* profileFlags= */ 0,
245             UserManager.USER_TYPE_PROFILE_CLONE);
246     shadowOf(userManager).addProfile(0, PROFILE_USER_HANDLE, profileUserInfo);
247     assertThat(userManager.isCloneProfile()).isFalse();
248 
249     setUserIdInContext(PROFILE_USER_HANDLE);
250     assertThat(userManager.isCloneProfile()).isTrue();
251   }
252 
253   @Test
254   @Config(minSdk = R)
isProfile_fullUser_returnsFalse()255   public void isProfile_fullUser_returnsFalse() {
256     assertThat(userManager.isProfile()).isFalse();
257   }
258 
259   @Test
260   @Config(minSdk = R)
isProfile_profileUser_returnsTrue()261   public void isProfile_profileUser_returnsTrue() {
262     shadowOf(userManager).addUser(TEST_USER_HANDLE, "", 0);
263     shadowOf(userManager).setMaxSupportedUsers(2);
264     UserHandle profileHandle =
265         userManager.createProfile(PROFILE_USER_NAME, UserManager.USER_TYPE_PROFILE_MANAGED, null);
266     assertThat(userManager.isProfile()).isFalse();
267 
268     setUserIdInContext(profileHandle.getIdentifier());
269     assertThat(userManager.isProfile()).isTrue();
270   }
271 
272   @Test
enforcePermissionChecks()273   public void enforcePermissionChecks() {
274     shadowOf(userManager).enforcePermissionChecks(true);
275 
276     try {
277       userManager.isManagedProfile();
278       fail("Expected exception");
279     } catch (SecurityException expected) {
280     }
281 
282     setPermissions(permission.MANAGE_USERS);
283 
284     shadowOf(userManager).setManagedProfile(true);
285 
286     assertThat(userManager.isManagedProfile()).isTrue();
287   }
288 
289   @Test
shouldGetSerialNumberForUser()290   public void shouldGetSerialNumberForUser() {
291     long serialNumberInvalid = -1L;
292 
293     UserHandle userHandle = newUserHandle(10);
294     assertThat(userManager.getSerialNumberForUser(userHandle)).isEqualTo(serialNumberInvalid);
295     assertThat(userManager.getUserSerialNumber(userHandle.getIdentifier()))
296         .isEqualTo(serialNumberInvalid);
297 
298     shadowOf(userManager).addUserProfile(userHandle);
299 
300     assertThat(userManager.getSerialNumberForUser(userHandle)).isNotEqualTo(serialNumberInvalid);
301     assertThat(userManager.getUserSerialNumber(userHandle.getIdentifier()))
302         .isNotEqualTo(serialNumberInvalid);
303   }
304 
305   @Test
getUserForNonExistSerialNumber()306   public void getUserForNonExistSerialNumber() {
307     long nonExistSerialNumber = 121;
308     assertThat(userManager.getUserForSerialNumber(nonExistSerialNumber)).isNull();
309     assertThat(userManager.getUserHandle((int) nonExistSerialNumber)).isEqualTo(-1);
310   }
311 
312   @Test
shouldGetSerialNumberForProfile()313   public void shouldGetSerialNumberForProfile() {
314     long serialNumberInvalid = -1L;
315 
316     assertThat(userManager.getUserSerialNumber(11)).isEqualTo(serialNumberInvalid);
317     shadowOf(userManager).addProfile(10, 11, "profile", 0);
318     assertThat(userManager.getUserSerialNumber(11)).isNotEqualTo(serialNumberInvalid);
319   }
320 
321   @Test
shouldGetUserHandleFromSerialNumberForProfile()322   public void shouldGetUserHandleFromSerialNumberForProfile() {
323     long serialNumberInvalid = -1L;
324 
325     shadowOf(userManager).addProfile(10, 11, "profile", 0);
326     long serialNumber = userManager.getUserSerialNumber(11);
327     assertThat(serialNumber).isNotEqualTo(serialNumberInvalid);
328     assertThat(userManager.getUserHandle((int) serialNumber)).isEqualTo(11);
329   }
330 
331   @Test
getSerialNumberForUser_returnsSetSerialNumberForUser()332   public void getSerialNumberForUser_returnsSetSerialNumberForUser() {
333     UserHandle userHandle = newUserHandle(0);
334     shadowOf(userManager).setSerialNumberForUser(userHandle, 123L);
335     assertThat(userManager.getSerialNumberForUser(userHandle)).isEqualTo(123L);
336   }
337 
338   @Test
getUserHandle()339   public void getUserHandle() {
340     UserHandle expectedUserHandle = shadowOf(userManager).addUser(10, "secondary_user", 0);
341 
342     long serialNumber = userManager.getUserSerialNumber(10);
343     int actualUserHandle = shadowOf(userManager).getUserHandle((int) serialNumber);
344     assertThat(actualUserHandle).isEqualTo(expectedUserHandle.getIdentifier());
345   }
346 
347   @Test
348   @Config(minSdk = R)
getUserHandles()349   public void getUserHandles() {
350     assertThat(shadowOf(userManager).getUserHandles(/* excludeDying= */ true).size()).isEqualTo(1);
351     shadowOf(userManager).getUserHandles(/* excludeDying= */ true).get(0);
352     assertThat(UserHandle.myUserId()).isEqualTo(UserHandle.USER_SYSTEM);
353 
354     UserHandle expectedUserHandle = shadowOf(userManager).addUser(10, "secondary_user", 0);
355     assertThat(shadowOf(userManager).getUserHandles(/* excludeDying= */ true).size()).isEqualTo(2);
356     assertThat(shadowOf(userManager).getUserHandles(/* excludeDying= */ true).get(1))
357         .isEqualTo(expectedUserHandle);
358   }
359 
360   @Test
361   @Config(minSdk = N_MR1, maxSdk = Q)
isDemoUser()362   public void isDemoUser() {
363     // All methods are based on the current user, so no need to pass a UserHandle.
364     assertThat(userManager.isDemoUser()).isFalse();
365 
366     shadowOf(userManager).setIsDemoUser(true);
367     assertThat(userManager.isDemoUser()).isTrue();
368 
369     shadowOf(userManager).setIsDemoUser(false);
370     assertThat(userManager.isDemoUser()).isFalse();
371   }
372 
373   @Test
374   @Config(minSdk = M)
isSystemUser()375   public void isSystemUser() {
376     assertThat(userManager.isSystemUser()).isTrue();
377 
378     shadowOf(userManager).setIsSystemUser(false);
379     assertThat(userManager.isSystemUser()).isFalse();
380 
381     shadowOf(userManager).setIsSystemUser(true);
382     assertThat(userManager.isSystemUser()).isTrue();
383   }
384 
385   @Test
386   @Config(minSdk = N)
isPrimaryUser()387   public void isPrimaryUser() {
388     assertThat(userManager.isPrimaryUser()).isTrue();
389 
390     shadowOf(userManager).setIsPrimaryUser(false);
391     assertThat(userManager.isPrimaryUser()).isFalse();
392 
393     shadowOf(userManager).setIsPrimaryUser(true);
394     assertThat(userManager.isPrimaryUser()).isTrue();
395   }
396 
397   @Test
isLinkedUser()398   public void isLinkedUser() {
399     assertThat(userManager.isLinkedUser()).isFalse();
400 
401     shadowOf(userManager).setIsLinkedUser(true);
402     assertThat(userManager.isLinkedUser()).isTrue();
403 
404     shadowOf(userManager).setIsLinkedUser(false);
405     assertThat(userManager.isLinkedUser()).isFalse();
406   }
407 
408   @Test
409   @Config(minSdk = Build.VERSION_CODES.Q)
isRestrictedProfile()410   public void isRestrictedProfile() {
411     assertThat(userManager.isRestrictedProfile()).isFalse();
412 
413     shadowOf(userManager).setIsRestrictedProfile(true);
414     assertThat(userManager.isRestrictedProfile()).isTrue();
415 
416     shadowOf(userManager).setIsRestrictedProfile(false);
417     assertThat(userManager.isRestrictedProfile()).isFalse();
418   }
419 
420   @Test
421   @Config(minSdk = Build.VERSION_CODES.N)
setSeedAccountName()422   public void setSeedAccountName() {
423     assertThat(userManager.getSeedAccountName()).isNull();
424 
425     shadowOf(userManager).setSeedAccountName(SEED_ACCOUNT_NAME);
426     assertThat(userManager.getSeedAccountName()).isEqualTo(SEED_ACCOUNT_NAME);
427   }
428 
429   @Test
430   @Config(minSdk = Build.VERSION_CODES.N)
setSeedAccountType()431   public void setSeedAccountType() {
432     assertThat(userManager.getSeedAccountType()).isNull();
433 
434     shadowOf(userManager).setSeedAccountType(SEED_ACCOUNT_TYPE);
435     assertThat(userManager.getSeedAccountType()).isEqualTo(SEED_ACCOUNT_TYPE);
436   }
437 
438   @Test
439   @Config(minSdk = Build.VERSION_CODES.N)
setSeedAccountOptions()440   public void setSeedAccountOptions() {
441     assertThat(userManager.getSeedAccountOptions()).isNull();
442 
443     PersistableBundle options = new PersistableBundle();
444     shadowOf(userManager).setSeedAccountOptions(options);
445     assertThat(userManager.getSeedAccountOptions()).isEqualTo(options);
446   }
447 
448   @Test
449   @Config(minSdk = Build.VERSION_CODES.N)
clearSeedAccountData()450   public void clearSeedAccountData() {
451     shadowOf(userManager).setSeedAccountName(SEED_ACCOUNT_NAME);
452     shadowOf(userManager).setSeedAccountType(SEED_ACCOUNT_TYPE);
453     shadowOf(userManager).setSeedAccountOptions(new PersistableBundle());
454 
455     assertThat(userManager.getSeedAccountName()).isNotNull();
456     assertThat(userManager.getSeedAccountType()).isNotNull();
457     assertThat(userManager.getSeedAccountOptions()).isNotNull();
458 
459     userManager.clearSeedAccountData();
460 
461     assertThat(userManager.getSeedAccountName()).isNull();
462     assertThat(userManager.getSeedAccountType()).isNull();
463     assertThat(userManager.getSeedAccountOptions()).isNull();
464   }
465 
466   @Test
isGuestUser()467   public void isGuestUser() {
468     assertThat(userManager.isGuestUser()).isFalse();
469 
470     shadowOf(userManager).setIsGuestUser(true);
471     assertThat(userManager.isGuestUser()).isTrue();
472 
473     shadowOf(userManager).setIsGuestUser(false);
474     assertThat(userManager.isGuestUser()).isFalse();
475   }
476 
477   @Test
isUserRunning()478   public void isUserRunning() {
479     UserHandle userHandle = newUserHandle(0);
480 
481     assertThat(userManager.isUserRunning(userHandle)).isFalse();
482 
483     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_UNLOCKED);
484     assertThat(userManager.isUserRunning(userHandle)).isTrue();
485 
486     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_LOCKED);
487     assertThat(userManager.isUserRunning(userHandle)).isTrue();
488 
489     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_UNLOCKING);
490     assertThat(userManager.isUserRunning(userHandle)).isTrue();
491 
492     shadowOf(userManager).setUserState(userHandle, UserState.STATE_STOPPING);
493     assertThat(userManager.isUserRunning(userHandle)).isFalse();
494 
495     shadowOf(userManager).setUserState(userHandle, UserState.STATE_BOOTING);
496     assertThat(userManager.isUserRunning(userHandle)).isFalse();
497 
498     shadowOf(userManager).setUserState(userHandle, UserState.STATE_SHUTDOWN);
499     assertThat(userManager.isUserRunning(userHandle)).isFalse();
500   }
501 
502   @Test
isUserRunningOrStopping()503   public void isUserRunningOrStopping() {
504     UserHandle userHandle = newUserHandle(0);
505 
506     assertThat(userManager.isUserRunningOrStopping(userHandle)).isFalse();
507 
508     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_UNLOCKED);
509     assertThat(userManager.isUserRunningOrStopping(userHandle)).isTrue();
510 
511     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_LOCKED);
512     assertThat(userManager.isUserRunningOrStopping(userHandle)).isTrue();
513 
514     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_UNLOCKING);
515     assertThat(userManager.isUserRunningOrStopping(userHandle)).isTrue();
516 
517     shadowOf(userManager).setUserState(userHandle, UserState.STATE_STOPPING);
518     assertThat(userManager.isUserRunningOrStopping(userHandle)).isTrue();
519 
520     shadowOf(userManager).setUserState(userHandle, UserState.STATE_BOOTING);
521     assertThat(userManager.isUserRunningOrStopping(userHandle)).isFalse();
522 
523     shadowOf(userManager).setUserState(userHandle, UserState.STATE_SHUTDOWN);
524     assertThat(userManager.isUserRunningOrStopping(userHandle)).isFalse();
525   }
526 
527   @Test
528   @Config(minSdk = R)
isUserUnlockingOrUnlocked()529   public void isUserUnlockingOrUnlocked() {
530     UserHandle userHandle = newUserHandle(0);
531 
532     assertThat(userManager.isUserUnlockingOrUnlocked(userHandle)).isFalse();
533 
534     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_UNLOCKED);
535     assertThat(userManager.isUserUnlockingOrUnlocked(userHandle)).isTrue();
536 
537     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_LOCKED);
538     assertThat(userManager.isUserUnlockingOrUnlocked(userHandle)).isFalse();
539 
540     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_UNLOCKING);
541     assertThat(userManager.isUserUnlockingOrUnlocked(userHandle)).isTrue();
542 
543     shadowOf(userManager).setUserState(userHandle, UserState.STATE_STOPPING);
544     assertThat(userManager.isUserUnlockingOrUnlocked(userHandle)).isFalse();
545 
546     shadowOf(userManager).setUserState(userHandle, UserState.STATE_BOOTING);
547     assertThat(userManager.isUserUnlockingOrUnlocked(userHandle)).isFalse();
548 
549     shadowOf(userManager).setUserState(userHandle, UserState.STATE_SHUTDOWN);
550     assertThat(userManager.isUserUnlockingOrUnlocked(userHandle)).isFalse();
551   }
552 
553   @Test
554   @Config(minSdk = 24)
isUserUnlockedByUserHandle()555   public void isUserUnlockedByUserHandle() {
556     UserHandle userHandle = newUserHandle(0);
557 
558     assertThat(userManager.isUserUnlocked(userHandle)).isFalse();
559 
560     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_UNLOCKED);
561     assertThat(userManager.isUserUnlocked(userHandle)).isTrue();
562 
563     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_LOCKED);
564     assertThat(userManager.isUserUnlocked(userHandle)).isFalse();
565 
566     shadowOf(userManager).setUserState(userHandle, UserState.STATE_RUNNING_UNLOCKING);
567     assertThat(userManager.isUserUnlocked(userHandle)).isFalse();
568 
569     shadowOf(userManager).setUserState(userHandle, UserState.STATE_STOPPING);
570     assertThat(userManager.isUserUnlocked(userHandle)).isFalse();
571 
572     shadowOf(userManager).setUserState(userHandle, UserState.STATE_BOOTING);
573     assertThat(userManager.isUserUnlocked(userHandle)).isFalse();
574 
575     shadowOf(userManager).setUserState(userHandle, UserState.STATE_SHUTDOWN);
576     assertThat(userManager.isUserUnlocked(userHandle)).isFalse();
577   }
578 
579   @Test
addSecondaryUser()580   public void addSecondaryUser() {
581     assertThat(userManager.getUserCount()).isEqualTo(1);
582     UserHandle userHandle = shadowOf(userManager).addUser(10, "secondary_user", 0);
583     assertThat(userHandle.getIdentifier()).isEqualTo(10);
584     assertThat(userManager.getUserCount()).isEqualTo(2);
585   }
586 
587   @Test
removeSecondaryUser()588   public void removeSecondaryUser() {
589     shadowOf(userManager).addUser(10, "secondary_user", 0);
590     assertThat(shadowOf(userManager).removeUser(10)).isTrue();
591     assertThat(userManager.getUserCount()).isEqualTo(1);
592   }
593 
594   @Test
595   @Config(minSdk = Q)
removeSecondaryUser_withUserHandle()596   public void removeSecondaryUser_withUserHandle() {
597     shadowOf(userManager).addUser(10, "secondary_user", 0);
598     assertThat(shadowOf(userManager).removeUser(UserHandle.of(10))).isTrue();
599     assertThat(userManager.getUserCount()).isEqualTo(1);
600   }
601 
602   @Test
603   @Config(minSdk = Q)
removeSecondaryUser_noExistingUser_doesNotRemove()604   public void removeSecondaryUser_noExistingUser_doesNotRemove() {
605     assertThat(shadowOf(userManager).removeUser(UserHandle.of(10))).isFalse();
606     assertThat(userManager.getUserCount()).isEqualTo(1);
607   }
608 
609   @Test
610   @Config(minSdk = TIRAMISU)
removeUserWhenPossible_twoUsersRemoveOne_hasOneUserLeft()611   public void removeUserWhenPossible_twoUsersRemoveOne_hasOneUserLeft() {
612     shadowOf(userManager).addUser(10, "secondary_user", 0);
613     assertThat(
614             userManager.removeUserWhenPossible(
615                 UserHandle.of(10), /* overrideDevicePolicy= */ false))
616         .isEqualTo(UserManager.REMOVE_RESULT_REMOVED);
617     assertThat(userManager.getUserCount()).isEqualTo(1);
618   }
619 
620   @Test
621   @Config(minSdk = TIRAMISU)
removeUserWhenPossible_nonExistingUser_fails()622   public void removeUserWhenPossible_nonExistingUser_fails() {
623     assertThat(
624             userManager.removeUserWhenPossible(
625                 UserHandle.of(10), /* overrideDevicePolicy= */ false))
626         .isEqualTo(UserManager.REMOVE_RESULT_ERROR_UNKNOWN);
627     assertThat(userManager.getUserCount()).isEqualTo(1);
628   }
629 
630   @Test
switchToSecondaryUser()631   public void switchToSecondaryUser() {
632     shadowOf(userManager).addUser(10, "secondary_user", 0);
633     shadowOf(userManager).switchUser(10);
634     assertThat(UserHandle.myUserId()).isEqualTo(10);
635   }
636 
637   @Test
638   @Config(minSdk = M)
switchToSecondaryUser_system()639   public void switchToSecondaryUser_system() {
640     assertThat(userManager.isSystemUser()).isTrue();
641     shadowOf(userManager).addUser(10, "secondary_user", 0);
642     shadowOf(userManager).switchUser(10);
643 
644     assertThat(userManager.isSystemUser()).isFalse();
645   }
646 
647   @Test
648   @Config(minSdk = N)
canSwitchUsers()649   public void canSwitchUsers() {
650     shadowOf(userManager).setCanSwitchUser(false);
651     assertThat(shadowOf(userManager).canSwitchUsers()).isFalse();
652     shadowOf(userManager).setCanSwitchUser(true);
653     assertThat(shadowOf(userManager).canSwitchUsers()).isTrue();
654   }
655 
656   @Test
657   @Config(minSdk = N)
getSerialNumbersOfUsers()658   public void getSerialNumbersOfUsers() {
659     assertThat(userManager.getSerialNumbersOfUsers(true)).hasLength(userManager.getUserCount());
660 
661     UserHandle userHandle = shadowOf(userManager).addUser(10, "secondary_user", 0);
662     int userSerialNumber = userManager.getUserSerialNumber(userHandle.getIdentifier());
663     long[] serialNumbers = userManager.getSerialNumbersOfUsers(true);
664 
665     assertThat(userHandle.getIdentifier()).isEqualTo(10);
666     assertThat(serialNumbers).hasLength(userManager.getUserCount());
667     assertThat(serialNumbers[0] == userSerialNumber || serialNumbers[1] == userSerialNumber)
668         .isTrue();
669   }
670 
671   @Test
getUsers()672   public void getUsers() {
673     assertThat(userManager.getUsers()).hasSize(1);
674     shadowOf(userManager).addUser(10, "secondary_user", 0);
675     assertThat(userManager.getUsers()).hasSize(2);
676     shadowOf(userManager).addProfile(10, 11, "profile", 0);
677     assertThat(userManager.getUsers()).hasSize(3);
678   }
679 
680   @Test
getUserInfo()681   public void getUserInfo() {
682     shadowOf(userManager).addUser(10, "secondary_user", 0);
683     assertThat(userManager.getUserInfo(10)).isNotNull();
684     assertThat(userManager.getUserInfo(10).name).isEqualTo("secondary_user");
685   }
686 
687   @Test
getUserInfoOfProfile()688   public void getUserInfoOfProfile() {
689     shadowOf(userManager).addProfile(10, 11, "profile_user", 0);
690     shadowOf(userManager).addProfile(10, 12, "profile_user_2", 0);
691     shadowOf(userManager).addProfile(13, 14, "profile_user_3", 0);
692     assertThat(userManager.getUserInfo(11)).isNotNull();
693     assertThat(userManager.getUserInfo(11).name).isEqualTo("profile_user");
694     assertThat(userManager.getUserInfo(12)).isNotNull();
695     assertThat(userManager.getUserInfo(12).name).isEqualTo("profile_user_2");
696     assertThat(userManager.getUserInfo(14)).isNotNull();
697     assertThat(userManager.getUserInfo(14).name).isEqualTo("profile_user_3");
698   }
699 
700   @Test
701   @Config(minSdk = N)
switchToUserNotAddedShouldThrowException()702   public void switchToUserNotAddedShouldThrowException() {
703     try {
704       shadowOf(userManager).switchUser(10);
705       fail("Switching to the user that was never added should throw UnsupportedOperationException");
706     } catch (UnsupportedOperationException e) {
707       assertThat(e).hasMessageThat().isEqualTo("Must add user before switching to it");
708     }
709   }
710 
711   @Test
getProfiles_addedProfile_containsProfile()712   public void getProfiles_addedProfile_containsProfile() {
713     shadowOf(userManager).addUser(TEST_USER_HANDLE, "", 0);
714     shadowOf(userManager)
715         .addProfile(TEST_USER_HANDLE, PROFILE_USER_HANDLE, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
716 
717     // getProfiles(userId) include user itself and associated profiles.
718     assertThat(userManager.getProfiles(TEST_USER_HANDLE).get(0).id).isEqualTo(TEST_USER_HANDLE);
719     assertThat(userManager.getProfiles(TEST_USER_HANDLE).get(1).id).isEqualTo(PROFILE_USER_HANDLE);
720   }
721 
722   @Test
723   @Config(minSdk = R)
getEnabledProfiles()724   public void getEnabledProfiles() {
725     shadowOf(userManager).addUser(TEST_USER_HANDLE, "", 0);
726     shadowOf(userManager).addProfile(TEST_USER_HANDLE, 10, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
727     shadowOf(userManager).addProfile(TEST_USER_HANDLE, 11, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
728     shadowOf(userManager).setIsUserEnabled(11, false);
729 
730     assertThat(userManager.getEnabledProfiles()).hasSize(2);
731     assertThat(userManager.getEnabledProfiles().get(0).getIdentifier()).isEqualTo(TEST_USER_HANDLE);
732     assertThat(userManager.getEnabledProfiles().get(1).getIdentifier()).isEqualTo(10);
733   }
734 
735   @Test
736   @Config(minSdk = R)
getAllProfiles()737   public void getAllProfiles() {
738     shadowOf(userManager).addUser(TEST_USER_HANDLE, "", 0);
739     shadowOf(userManager).addProfile(TEST_USER_HANDLE, 10, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
740     shadowOf(userManager).addProfile(TEST_USER_HANDLE, 11, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
741     shadowOf(userManager).setIsUserEnabled(11, false);
742 
743     assertThat(userManager.getAllProfiles()).hasSize(3);
744     assertThat(userManager.getAllProfiles().get(0).getIdentifier()).isEqualTo(TEST_USER_HANDLE);
745     assertThat(userManager.getAllProfiles().get(1).getIdentifier()).isEqualTo(10);
746     assertThat(userManager.getAllProfiles().get(2).getIdentifier()).isEqualTo(11);
747   }
748 
749   @Test
750   @Config(minSdk = R)
createProfile_maxUsersReached_returnsNull()751   public void createProfile_maxUsersReached_returnsNull() {
752     shadowOf(userManager).addUser(TEST_USER_HANDLE, "", 0);
753     shadowOf(userManager).setMaxSupportedUsers(1);
754     assertThat(
755             userManager.createProfile(
756                 PROFILE_USER_NAME, UserManager.USER_TYPE_PROFILE_MANAGED, null))
757         .isNull();
758   }
759 
760   @Test
761   @Config(minSdk = R)
createProfile_setsGivenUserName()762   public void createProfile_setsGivenUserName() {
763     shadowOf(userManager).addUser(TEST_USER_HANDLE, "", 0);
764     shadowOf(userManager).setMaxSupportedUsers(2);
765     userManager.createProfile(PROFILE_USER_NAME, UserManager.USER_TYPE_PROFILE_MANAGED, null);
766 
767     setUserIdInContext(ShadowUserManager.DEFAULT_SECONDARY_USER_ID);
768     assertThat(userManager.getUserName()).isEqualTo(PROFILE_USER_NAME);
769   }
770 
771   @Test
772   @Config(minSdk = R)
createProfile_userIdIncreasesFromDefault()773   public void createProfile_userIdIncreasesFromDefault() {
774     shadowOf(userManager).addUser(TEST_USER_HANDLE, "", 0);
775     shadowOf(userManager).setMaxSupportedUsers(3);
776     UserHandle newUser1 =
777         userManager.createProfile("profile A", UserManager.USER_TYPE_PROFILE_MANAGED, null);
778     UserHandle newUser2 =
779         userManager.createProfile("profile B", UserManager.USER_TYPE_PROFILE_MANAGED, null);
780 
781     assertThat(newUser1.getIdentifier()).isEqualTo(ShadowUserManager.DEFAULT_SECONDARY_USER_ID);
782     assertThat(newUser2.getIdentifier()).isEqualTo(ShadowUserManager.DEFAULT_SECONDARY_USER_ID + 1);
783   }
784 
785   @Test
786   @Config(minSdk = Q)
getProfileParent_returnsNullForUser()787   public void getProfileParent_returnsNullForUser() {
788     assertThat(userManager.getProfileParent(UserHandle.of(0))).isNull();
789   }
790 
791   @Test
792   @Config(minSdk = Q)
getProfileParent_returnsNullForParent()793   public void getProfileParent_returnsNullForParent() {
794     shadowOf(userManager)
795         .addProfile(TEST_USER_HANDLE, PROFILE_USER_HANDLE, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
796     assertThat(userManager.getProfileParent(UserHandle.of(TEST_USER_HANDLE))).isNull();
797   }
798 
799   @Test
800   @Config(minSdk = Q)
getProfileParent_returnsParentForProfile()801   public void getProfileParent_returnsParentForProfile() {
802     shadowOf(userManager)
803         .addProfile(TEST_USER_HANDLE, PROFILE_USER_HANDLE, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
804     assertThat(userManager.getProfileParent(UserHandle.of(PROFILE_USER_HANDLE)))
805         .isEqualTo(UserHandle.of(TEST_USER_HANDLE));
806   }
807 
808   @Test
809   @Config(minSdk = R)
isSameProfileGroup_sameNonParentUser_returnsFalse()810   public void isSameProfileGroup_sameNonParentUser_returnsFalse() {
811     assertThat(
812             userManager.isSameProfileGroup(
813                 UserHandle.of(TEST_USER_HANDLE), UserHandle.of(TEST_USER_HANDLE)))
814         .isFalse();
815   }
816 
817   @Test
818   @Config(minSdk = R)
isSameProfileGroup_sameParentUser_returnsTrue()819   public void isSameProfileGroup_sameParentUser_returnsTrue() {
820     shadowOf(userManager)
821         .addProfile(TEST_USER_HANDLE, PROFILE_USER_HANDLE, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
822     assertThat(
823             userManager.isSameProfileGroup(
824                 UserHandle.of(TEST_USER_HANDLE), UserHandle.of(TEST_USER_HANDLE)))
825         .isTrue();
826   }
827 
828   @Test
829   @Config(minSdk = R)
isSameProfileGroup_parentAndProfile_returnsTrue()830   public void isSameProfileGroup_parentAndProfile_returnsTrue() {
831     shadowOf(userManager)
832         .addProfile(TEST_USER_HANDLE, PROFILE_USER_HANDLE, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
833     assertThat(
834             userManager.isSameProfileGroup(
835                 UserHandle.of(PROFILE_USER_HANDLE), UserHandle.of(TEST_USER_HANDLE)))
836         .isTrue();
837   }
838 
839   @Test
840   @Config(minSdk = R)
isSameProfileGroup_twoProfilesOfSameUser_returnsTrue()841   public void isSameProfileGroup_twoProfilesOfSameUser_returnsTrue() {
842     shadowOf(userManager).addProfile(TEST_USER_HANDLE, 10, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
843     shadowOf(userManager).addProfile(TEST_USER_HANDLE, 11, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
844 
845     assertThat(userManager.isSameProfileGroup(UserHandle.of(10), UserHandle.of(11))).isTrue();
846   }
847 
848   @Test
849   @Config(minSdk = R)
isSameProfileGroup_profilesOfDifferentUsers_returnsFalse()850   public void isSameProfileGroup_profilesOfDifferentUsers_returnsFalse() {
851     shadowOf(userManager).addProfile(0, 10, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
852     shadowOf(userManager).addProfile(1, 11, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
853 
854     assertThat(userManager.isSameProfileGroup(UserHandle.of(10), UserHandle.of(11))).isFalse();
855   }
856 
857   @Test
858   @Config(minSdk = R)
setUserName()859   public void setUserName() {
860     shadowOf(userManager).addUser(TEST_USER_HANDLE, "", 0);
861     shadowOf(userManager)
862         .addProfile(TEST_USER_HANDLE, PROFILE_USER_HANDLE, PROFILE_USER_NAME, PROFILE_USER_FLAGS);
863 
864     userManager.setUserName("new user name");
865 
866     setUserIdInContext(PROFILE_USER_HANDLE);
867     userManager.setUserName("new profile name");
868     assertThat(userManager.getUserName()).isEqualTo("new profile name");
869 
870     setUserIdInContext(TEST_USER_HANDLE);
871     assertThat(userManager.getUserName()).isEqualTo("new user name");
872   }
873 
874   @Test
875   @Config(minSdk = R)
isUserOfType()876   public void isUserOfType() {
877     shadowOf(userManager).addUser(TEST_USER_HANDLE, "", 0);
878     shadowOf(userManager).setMaxSupportedUsers(2);
879     UserHandle newUser =
880         userManager.createProfile(PROFILE_USER_NAME, UserManager.USER_TYPE_PROFILE_MANAGED, null);
881     assertThat(userManager.isUserOfType(UserManager.USER_TYPE_PROFILE_MANAGED)).isFalse();
882 
883     setUserIdInContext(newUser.getIdentifier());
884     assertThat(userManager.isUserOfType(UserManager.USER_TYPE_PROFILE_MANAGED)).isTrue();
885   }
886 
887   @Test
getMaxSupportedUsers()888   public void getMaxSupportedUsers() {
889     assertThat(UserManager.getMaxSupportedUsers()).isEqualTo(1);
890     shadowOf(userManager).setMaxSupportedUsers(5);
891     assertThat(UserManager.getMaxSupportedUsers()).isEqualTo(5);
892   }
893 
894   @Test
895   @Config(minSdk = N)
supportsMultipleUsers()896   public void supportsMultipleUsers() {
897     assertThat(UserManager.supportsMultipleUsers()).isFalse();
898 
899     shadowOf(userManager).setSupportsMultipleUsers(true);
900     assertThat(UserManager.supportsMultipleUsers()).isTrue();
901   }
902 
903   @Test
904   @Config(minSdk = Q)
getUserSwitchability_shouldReturnLastSetSwitchability()905   public void getUserSwitchability_shouldReturnLastSetSwitchability() {
906     assertThat(userManager.getUserSwitchability()).isEqualTo(UserManager.SWITCHABILITY_STATUS_OK);
907     shadowOf(userManager)
908         .setUserSwitchability(UserManager.SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED);
909     assertThat(userManager.getUserSwitchability())
910         .isEqualTo(UserManager.SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED);
911     shadowOf(userManager).setUserSwitchability(UserManager.SWITCHABILITY_STATUS_OK);
912     assertThat(userManager.getUserSwitchability()).isEqualTo(UserManager.SWITCHABILITY_STATUS_OK);
913   }
914 
915   @Test
916   @Config(minSdk = Q)
setCanSwitchUser_shouldChangeSwitchabilityState()917   public void setCanSwitchUser_shouldChangeSwitchabilityState() {
918     shadowOf(userManager).setCanSwitchUser(false);
919     assertThat(userManager.getUserSwitchability())
920         .isEqualTo(UserManager.SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED);
921     shadowOf(userManager).setCanSwitchUser(true);
922     assertThat(userManager.getUserSwitchability()).isEqualTo(UserManager.SWITCHABILITY_STATUS_OK);
923   }
924 
925   @Test
926   @Config(minSdk = N, maxSdk = Q)
canSwitchUser_shouldReflectSwitchabilityState()927   public void canSwitchUser_shouldReflectSwitchabilityState() {
928     shadowOf(userManager)
929         .setUserSwitchability(UserManager.SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED);
930     assertThat(userManager.canSwitchUsers()).isFalse();
931     shadowOf(userManager).setUserSwitchability(UserManager.SWITCHABILITY_STATUS_OK);
932     assertThat(userManager.canSwitchUsers()).isTrue();
933   }
934 
935   @Test
936   @Config(minSdk = Q)
getUserName_shouldReturnSetUserName()937   public void getUserName_shouldReturnSetUserName() {
938     shadowOf(userManager).setUserSwitchability(UserManager.SWITCHABILITY_STATUS_OK);
939     shadowOf(userManager).addUser(10, PROFILE_USER_NAME, /* flags= */ 0);
940     shadowOf(userManager).switchUser(10);
941     assertThat(userManager.getUserName()).isEqualTo(PROFILE_USER_NAME);
942   }
943 
944   @Test
945   @Config(minSdk = Q)
getUserIcon_shouldReturnSetUserIcon()946   public void getUserIcon_shouldReturnSetUserIcon() {
947     userManager.setUserIcon(TEST_USER_ICON);
948     assertThat(userManager.getUserIcon()).isEqualTo(TEST_USER_ICON);
949 
950     shadowOf(userManager).addUser(10, PROFILE_USER_NAME, /* flags= */ 0);
951     shadowOf(userManager).switchUser(10);
952     assertThat(userManager.getUserIcon()).isNull();
953   }
954 
955   @Test
956   @Config(minSdk = N)
isQuietModeEnabled_shouldReturnFalse()957   public void isQuietModeEnabled_shouldReturnFalse() {
958     assertThat(userManager.isQuietModeEnabled(Process.myUserHandle())).isFalse();
959   }
960 
961   @Test
962   @Config(minSdk = N)
isQuietModeEnabled_withProfile_shouldReturnFalse()963   public void isQuietModeEnabled_withProfile_shouldReturnFalse() {
964     shadowOf(userManager).addProfile(0, 10, "Work profile", UserInfo.FLAG_MANAGED_PROFILE);
965 
966     assertThat(userManager.isQuietModeEnabled(new UserHandle(10))).isFalse();
967   }
968 
969   @Test
970   @Config(minSdk = N)
isQuietModeEnabled_withProfileQuietMode_shouldReturnTrue()971   public void isQuietModeEnabled_withProfileQuietMode_shouldReturnTrue() {
972     shadowOf(userManager)
973         .addProfile(
974             0, 10, "Work profile", UserInfo.FLAG_MANAGED_PROFILE | UserInfo.FLAG_QUIET_MODE);
975 
976     assertThat(userManager.isQuietModeEnabled(new UserHandle(10))).isTrue();
977   }
978 
979   @Test
980   @Config(minSdk = Q)
requestQuietModeEnabled_withoutPermission_shouldThrowException()981   public void requestQuietModeEnabled_withoutPermission_shouldThrowException() {
982     shadowOf(userManager).enforcePermissionChecks(true);
983 
984     shadowOf(userManager).addProfile(0, 10, "Work profile", UserInfo.FLAG_MANAGED_PROFILE);
985 
986     UserHandle workHandle = new UserHandle(10);
987     try {
988       userManager.requestQuietModeEnabled(true, workHandle);
989       fail("Expected SecurityException.");
990     } catch (SecurityException expected) {
991     }
992   }
993 
994   @Test
995   @Config(minSdk = Q)
requestQuietModeEnabled_withManagedProfile_shouldStopProfileAndEmitBroadcast()996   public void requestQuietModeEnabled_withManagedProfile_shouldStopProfileAndEmitBroadcast() {
997     shadowOf(userManager).enforcePermissionChecks(true);
998     setPermissions(permission.MODIFY_QUIET_MODE);
999 
1000     UserHandle workHandle =
1001         shadowOf(userManager).addUser(10, "Work profile", UserInfo.FLAG_MANAGED_PROFILE);
1002     shadowOf(userManager).setUserState(workHandle, UserState.STATE_RUNNING_UNLOCKED);
1003 
1004     final AtomicReference<String> receivedAction = new AtomicReference<>();
1005     final AtomicReference<UserHandle> receivedHandle = new AtomicReference<>();
1006 
1007     BroadcastReceiver receiver =
1008         new BroadcastReceiver() {
1009           @Override
1010           public void onReceive(Context context, Intent intent) {
1011             receivedAction.set(intent.getAction());
1012             receivedHandle.set(intent.getParcelableExtra(Intent.EXTRA_USER));
1013           }
1014         };
1015     IntentFilter intentFilter = new IntentFilter();
1016     intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_AVAILABLE);
1017     intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE);
1018     context.registerReceiver(receiver, intentFilter);
1019 
1020     assertThat(userManager.requestQuietModeEnabled(true, workHandle)).isTrue();
1021     shadowOf(Looper.getMainLooper()).idle();
1022 
1023     assertThat(userManager.isQuietModeEnabled(workHandle)).isTrue();
1024     assertThat(userManager.isUserRunning(workHandle)).isFalse();
1025     assertThat(userManager.getUserInfo(10).flags & UserInfo.FLAG_QUIET_MODE)
1026         .isEqualTo(UserInfo.FLAG_QUIET_MODE);
1027     assertThat(receivedAction.get()).isEqualTo(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE);
1028     assertThat(receivedHandle.get()).isEqualTo(workHandle);
1029   }
1030 
1031   @Test
1032   @Config(minSdk = Q)
requestQuietModeDisabled_withManagedProfile_shouldStartProfileAndEmitBroadcast()1033   public void requestQuietModeDisabled_withManagedProfile_shouldStartProfileAndEmitBroadcast() {
1034     shadowOf(userManager).enforcePermissionChecks(true);
1035     setPermissions(permission.MODIFY_QUIET_MODE);
1036 
1037     UserHandle workHandle =
1038         shadowOf(userManager)
1039             .addUser(10, "Work profile", UserInfo.FLAG_MANAGED_PROFILE | UserInfo.FLAG_QUIET_MODE);
1040     shadowOf(userManager).setUserState(workHandle, UserState.STATE_SHUTDOWN);
1041 
1042     final AtomicReference<String> receivedAction = new AtomicReference<>();
1043     final AtomicReference<UserHandle> receivedHandle = new AtomicReference<>();
1044 
1045     BroadcastReceiver receiver =
1046         new BroadcastReceiver() {
1047           @Override
1048           public void onReceive(Context context, Intent intent) {
1049             receivedAction.set(intent.getAction());
1050             receivedHandle.set(intent.getParcelableExtra(Intent.EXTRA_USER));
1051           }
1052         };
1053     IntentFilter intentFilter = new IntentFilter();
1054     intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_AVAILABLE);
1055     intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE);
1056     context.registerReceiver(receiver, intentFilter);
1057 
1058     assertThat(userManager.requestQuietModeEnabled(false, workHandle)).isTrue();
1059     shadowOf(Looper.getMainLooper()).idle();
1060 
1061     assertThat(userManager.isQuietModeEnabled(workHandle)).isFalse();
1062     assertThat(userManager.isUserRunning(workHandle)).isTrue();
1063     assertThat(userManager.getUserInfo(10).flags & UserInfo.FLAG_QUIET_MODE).isEqualTo(0);
1064     assertThat(receivedAction.get()).isEqualTo(Intent.ACTION_MANAGED_PROFILE_AVAILABLE);
1065     assertThat(receivedHandle.get()).isEqualTo(workHandle);
1066   }
1067 
1068   @Test
1069   @Config(minSdk = Q)
requestQuietModeDisabled_withLockedManagedProfile_shouldNotDoAnything()1070   public void requestQuietModeDisabled_withLockedManagedProfile_shouldNotDoAnything() {
1071     shadowOf(userManager).enforcePermissionChecks(true);
1072     setPermissions(permission.MODIFY_QUIET_MODE);
1073 
1074     UserHandle workHandle =
1075         shadowOf(userManager)
1076             .addUser(10, "Work profile", UserInfo.FLAG_MANAGED_PROFILE | UserInfo.FLAG_QUIET_MODE);
1077 
1078     final AtomicReference<String> receivedAction = new AtomicReference<>();
1079     final AtomicReference<UserHandle> receivedHandle = new AtomicReference<>();
1080 
1081     BroadcastReceiver receiver =
1082         new BroadcastReceiver() {
1083           @Override
1084           public void onReceive(Context context, Intent intent) {
1085             receivedAction.set(intent.getAction());
1086             receivedHandle.set(intent.getParcelableExtra(Intent.EXTRA_USER));
1087           }
1088         };
1089     IntentFilter intentFilter = new IntentFilter();
1090     intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_AVAILABLE);
1091     intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE);
1092     context.registerReceiver(receiver, intentFilter);
1093 
1094     shadowOf(userManager).setProfileIsLocked(workHandle, true);
1095 
1096     assertThat(userManager.requestQuietModeEnabled(false, workHandle)).isFalse();
1097     shadowOf(Looper.getMainLooper()).idle();
1098 
1099     assertThat(userManager.isQuietModeEnabled(workHandle)).isTrue();
1100     assertThat(userManager.isUserRunning(workHandle)).isFalse();
1101     assertThat(userManager.getUserInfo(10).flags & UserInfo.FLAG_QUIET_MODE)
1102         .isEqualTo(UserInfo.FLAG_QUIET_MODE);
1103     assertThat(receivedAction.get()).isNull();
1104     assertThat(receivedHandle.get()).isNull();
1105   }
1106 
1107   @Test
1108   @Config(minSdk = TIRAMISU)
someUserHasAccount()1109   public void someUserHasAccount() {
1110     assertThat(userManager.someUserHasAccount(SEED_ACCOUNT_NAME, SEED_ACCOUNT_TYPE)).isFalse();
1111 
1112     shadowOf(userManager).setSomeUserHasAccount(SEED_ACCOUNT_NAME, SEED_ACCOUNT_TYPE);
1113     assertThat(userManager.someUserHasAccount(SEED_ACCOUNT_NAME, SEED_ACCOUNT_TYPE)).isTrue();
1114 
1115     shadowOf(userManager).removeSomeUserHasAccount(SEED_ACCOUNT_NAME, SEED_ACCOUNT_TYPE);
1116     assertThat(userManager.someUserHasAccount(SEED_ACCOUNT_NAME, SEED_ACCOUNT_TYPE)).isFalse();
1117   }
1118 
1119   @Test
1120   @Config(minSdk = S)
isUserForeground_defaultValue_returnsTrue()1121   public void isUserForeground_defaultValue_returnsTrue() {
1122     assertThat(userManager.isUserForeground()).isTrue();
1123   }
1124 
1125   @Test
1126   @Config(minSdk = S)
isUserForeground_overridden_returnsNewValue()1127   public void isUserForeground_overridden_returnsNewValue() {
1128     shadowOf(userManager).setUserForeground(false);
1129 
1130     assertThat(userManager.isUserForeground()).isFalse();
1131   }
1132 
1133   @Test
1134   @Config(minSdk = S)
isUserForeground_valueToggled_returnsLatestValue()1135   public void isUserForeground_valueToggled_returnsLatestValue() {
1136     shadowOf(userManager).setUserForeground(false);
1137     shadowOf(userManager).setUserForeground(true);
1138 
1139     assertThat(userManager.isUserForeground()).isTrue();
1140   }
1141 
1142   @Test
1143   @Config(minSdk = O)
getEnforcingUsers()1144   public void getEnforcingUsers() {
1145     UserHandle userHandle = Process.myUserHandle();
1146 
1147     assertThat(userManager.hasUserRestriction(UserManager.ENSURE_VERIFY_APPS)).isFalse();
1148     assertThat(userManager.getUserRestrictionSources(UserManager.ENSURE_VERIFY_APPS, userHandle))
1149         .isEmpty();
1150 
1151     shadowOf(userManager).setUserRestriction(userHandle, UserManager.ENSURE_VERIFY_APPS, true);
1152     assertThat(userManager.hasUserRestriction(UserManager.ENSURE_VERIFY_APPS)).isTrue();
1153 
1154     List<EnforcingUser> sources =
1155         userManager.getUserRestrictionSources(UserManager.ENSURE_VERIFY_APPS, userHandle);
1156     assertThat(sources.get(0).getUserRestrictionSource())
1157         .isEqualTo(UserManager.RESTRICTION_SOURCE_SYSTEM);
1158 
1159     shadowOf(userManager).setUserRestriction(userHandle, UserManager.ENSURE_VERIFY_APPS, false);
1160     assertThat(userManager.getUserRestrictionSources(UserManager.ENSURE_VERIFY_APPS, userHandle))
1161         .isEmpty();
1162   }
1163 
1164   // Create user handle from parcel since UserHandle.of() was only added in later APIs.
newUserHandle(int uid)1165   private static UserHandle newUserHandle(int uid) {
1166     Parcel userParcel = Parcel.obtain();
1167     userParcel.writeInt(uid);
1168     userParcel.setDataPosition(0);
1169     return new UserHandle(userParcel);
1170   }
1171 
setUserIdInContext(int userId)1172   private static void setUserIdInContext(int userId) {
1173     Application application = ApplicationProvider.getApplicationContext();
1174     ShadowContextImpl shadowContext = Shadow.extract(application.getBaseContext());
1175     shadowContext.setUserId(userId);
1176   }
1177 
setPermissions(String... permissions)1178   private static void setPermissions(String... permissions) {
1179     Application context = ApplicationProvider.getApplicationContext();
1180     PackageInfo packageInfo =
1181         shadowOf(context.getPackageManager())
1182             .getInternalMutablePackageInfo(context.getPackageName());
1183     packageInfo.requestedPermissions = permissions;
1184   }
1185 
1186   @Test
1187   @Config(minSdk = O)
userManager_activityContextEnabled_consistentAcrossContexts()1188   public void userManager_activityContextEnabled_consistentAcrossContexts() {
1189     String originalProperty = System.getProperty("robolectric.createActivityContexts", "");
1190     System.setProperty("robolectric.createActivityContexts", "true");
1191     try (ActivityController<Activity> controller =
1192         Robolectric.buildActivity(Activity.class).setup()) {
1193       UserManager applicationUserManager =
1194           (UserManager)
1195               ApplicationProvider.getApplicationContext().getSystemService(Context.USER_SERVICE);
1196       Activity activity = controller.get();
1197       UserManager activityUserManager =
1198           (UserManager) activity.getSystemService(Context.USER_SERVICE);
1199 
1200       assertThat(applicationUserManager).isNotSameInstanceAs(activityUserManager);
1201 
1202       boolean isAdminApplication = applicationUserManager.isAdminUser();
1203       boolean isAdminActivity = activityUserManager.isAdminUser();
1204 
1205       assertThat(isAdminActivity).isEqualTo(isAdminApplication);
1206     } finally {
1207       System.setProperty("robolectric.createActivityContexts", originalProperty);
1208     }
1209   }
1210 }
1211