Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 21263774 authored by Felipe Leme's avatar Felipe Leme Committed by Android (Google) Code Review
Browse files

Merge "Minor improvements on UserInfoTest and UserManagerServiceUserInfoTest." into main

parents 779598b8 e4216ca4

core/tests/coretests/src/android/content/pm/UserInfoTest.java

+25 −29
Original line number Diff line number Diff line
@@ -26,26 +26,21 @@ import static android.os.UserManager.USER_TYPE_FULL_RESTRICTED; 
import static android.os.UserManager.USER_TYPE_FULL_SYSTEM;

import static android.os.UserManager.USER_TYPE_SYSTEM_HEADLESS;



import static com.google.common.truth.Truth.assertThat;



import android.content.pm.UserInfo.UserInfoFlag;

import android.os.UserHandle;

import android.platform.test.annotations.DisableFlags;

import android.platform.test.annotations.EnableFlags;

import android.platform.test.flag.junit.SetFlagsRule;



import androidx.test.ext.junit.runners.AndroidJUnit4;

import androidx.test.filters.SmallTest;



import com.google.common.truth.Expect;



import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;





@RunWith(AndroidJUnit4.class)

@SmallTest

@SuppressWarnings("deprecation")

public final class UserInfoTest {



    @Rule
@@ -56,39 +51,40 @@ public final class UserInfoTest { 


    @Test

    public void testSimple() throws Exception {

        final UserInfo ui = new UserInfo(10, "Test", UserInfo.FLAG_GUEST);

        UserInfo ui = createTestUserInfo(FLAG_GUEST);



        assertThat(ui.getUserHandle()).isEqualTo(UserHandle.of(10));

        assertThat(ui.name).isEqualTo("Test");

        expect.withMessage("getUserHandle()").that(ui.getUserHandle()).isEqualTo(UserHandle.of(10));

        expect.that(ui.name).isEqualTo("Test");



        // Derived based on userType field

        assertThat(ui.isManagedProfile()).isEqualTo(false);

        assertThat(ui.isGuest()).isEqualTo(true);

        assertThat(ui.isRestricted()).isEqualTo(false);

        assertThat(ui.isDemo()).isEqualTo(false);

        assertThat(ui.isCloneProfile()).isEqualTo(false);

        assertThat(ui.isCommunalProfile()).isEqualTo(false);

        assertThat(ui.isPrivateProfile()).isEqualTo(false);

        expect.withMessage("isManagedProfile()").that(ui.isManagedProfile()).isFalse();

        expect.withMessage("isGuest()").that(ui.isGuest()).isTrue();

        expect.withMessage("isRestricted()").that(ui.isRestricted()).isFalse();

        expect.withMessage("isDemo()").that(ui.isDemo()).isFalse();

        expect.withMessage("isCloneProfile()").that(ui.isCloneProfile()).isFalse();

        expect.withMessage("isCommunalProfile()").that(ui.isCommunalProfile()).isFalse();

        expect.withMessage("isPrivateProfile()").that(ui.isPrivateProfile()).isFalse();

        expect.withMessage("isSupervisingProfile()").that(ui.isSupervisingProfile()).isFalse();



        // Derived based on flags field

        assertThat(ui.isPrimary()).isEqualTo(false);

        assertThat(ui.isAdmin()).isEqualTo(false);

        assertThat(ui.isProfile()).isEqualTo(false);

        assertThat(ui.isEnabled()).isEqualTo(true);

        assertThat(ui.isQuietModeEnabled()).isEqualTo(false);

        assertThat(ui.isEphemeral()).isEqualTo(false);

        assertThat(ui.isForTesting()).isEqualTo(false);

        assertThat(ui.isInitialized()).isEqualTo(false);

        assertThat(ui.isFull()).isEqualTo(false);

        assertThat(ui.isMain()).isEqualTo(false);

        expect.withMessage("isPrimary()").that(ui.isPrimary()).isFalse();

        expect.withMessage("isAdmin()").that(ui.isAdmin()).isFalse();

        expect.withMessage("isProfile()").that(ui.isProfile()).isFalse();

        expect.withMessage("isEnabled()").that(ui.isEnabled()).isTrue();

        expect.withMessage("isQuietModeEnabled()").that(ui.isQuietModeEnabled()).isFalse();

        expect.withMessage("isEphemeral()").that(ui.isEphemeral()).isFalse();

        expect.withMessage("isForTesting()").that(ui.isForTesting()).isFalse();

        expect.withMessage("isInitialized()").that(ui.isInitialized()).isFalse();

        expect.withMessage("isFull()").that(ui.isFull()).isFalse();

        expect.withMessage("isMain()").that(ui.isMain()).isFalse();

    }



    @Test

    public void testDebug() throws Exception {

        final UserInfo ui = new UserInfo(10, "Test", UserInfo.FLAG_GUEST);

        UserInfo ui = createTestUserInfo(FLAG_GUEST);



        assertThat(ui.toString()).isNotEmpty();

        assertThat(ui.toFullString()).isNotEmpty();

        expect.withMessage("toString()").that(ui.toString()).isNotEmpty();

        expect.withMessage("toFullString()").that(ui.toFullString()).isNotEmpty();

    }



    @Test

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

+116 −81
Original line number Diff line number Diff line
@@ -15,7 +15,6 @@ 
 */



package com.android.server.pm;



import static android.content.pm.UserInfo.FLAG_DEMO;

import static android.content.pm.UserInfo.FLAG_DISABLED;

import static android.content.pm.UserInfo.FLAG_EPHEMERAL;
@@ -35,9 +34,7 @@ import static android.os.UserManager.USER_TYPE_FULL_SYSTEM; 
import static android.os.UserManager.USER_TYPE_PROFILE_MANAGED;

import static android.os.UserManager.USER_TYPE_SYSTEM_HEADLESS;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import static com.google.common.truth.Truth.assertWithMessage;



import android.annotation.UserIdInt;

import android.app.PropertyInvalidatedCache;
@@ -55,15 +52,16 @@ import android.util.Xml; 


import androidx.test.InstrumentationRegistry;

import androidx.test.filters.MediumTest;

import androidx.test.runner.AndroidJUnit4;



import com.android.frameworks.servicestests.R;

import com.android.server.LocalServices;

import com.android.server.pm.UserManagerService.UserData;



import com.google.common.truth.Expect;



import org.junit.Before;

import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.xmlpull.v1.XmlPullParser;

import org.xmlpull.v1.XmlSerializer;
@@ -74,14 +72,16 @@ import java.nio.charset.StandardCharsets; 
import java.util.List;



/**

 * <p>Run with:<pre>

 * runtest -c com.android.server.pm.UserManagerServiceUserInfoTest frameworks-services

 * </pre>

 * Run with

 * {@code atest FrameworksServicesTests:com.android.server.pm.UserManagerServiceUserInfoTest}.

 */

@Presubmit

@RunWith(AndroidJUnit4.class)

@MediumTest

public class UserManagerServiceUserInfoTest {

@SuppressWarnings("deprecation")

public final class UserManagerServiceUserInfoTest {



    @Rule public final Expect expect = Expect.create();



    private UserManagerService mUserManagerService;

    private Resources mResources;
@@ -100,9 +100,10 @@ public class UserManagerServiceUserInfoTest { 


        // The tests assume that the device has one user and its the system user.

        List<UserInfo> users = mUserManagerService.getUsers(/* excludeDying */ false);

        assertEquals("Multiple users so this test can't run.", 1, users.size());

        assertEquals("Only user present isn't the system user.",

                UserHandle.USER_SYSTEM, users.get(0).id);

        assertWithMessage("initial users").that(users).isNotNull();

        assertWithMessage("initial users").that(users).hasSize(1);

        expect.withMessage("only user present initially is the system user.").that(users.get(0).id)

                .isEqualTo(UserHandle.USER_SYSTEM);



        mResources = InstrumentationRegistry.getTargetContext().getResources();

    }
@@ -164,17 +165,21 @@ public class UserManagerServiceUserInfoTest { 
                    new ByteArrayInputStream(systemUserBytes), userVersion);

        }



        assertTrue(mUserManagerService.hasUserRestrictionOnAnyUser(globalRestriction));

        assertTrue(mUserManagerService.hasUserRestrictionOnAnyUser(localRestriction));

        expect.withMessage("hasUserRestrictionOnAnyUser(%s)", globalRestriction)

                .that(mUserManagerService.hasUserRestrictionOnAnyUser(globalRestriction)).isTrue();

        expect.withMessage("hasUserRestrictionOnAnyUser(%s)", localRestriction)

                .that(mUserManagerService.hasUserRestrictionOnAnyUser(localRestriction)).isTrue();

    }



    /** Sets a global and local restriction and verifies they were set properly **/

    private void setUserRestrictions(int id, String global, String local, boolean enabled) {

        mUserManagerService.setUserRestrictionInner(UserHandle.USER_ALL, global, enabled);

        assertEquals(mUserManagerService.hasUserRestrictionOnAnyUser(global), enabled);

        expect.withMessage("hasUserRestrictionOnAnyUser(%s)", global)

                .that(mUserManagerService.hasUserRestrictionOnAnyUser(global)).isEqualTo(enabled);



        mUserManagerService.setUserRestrictionInner(id, local, enabled);

        assertEquals(mUserManagerService.hasUserRestrictionOnAnyUser(local), enabled);

        expect.withMessage("hasUserRestrictionOnAnyUser(%s)", local)

                .that(mUserManagerService.hasUserRestrictionOnAnyUser(local)).isEqualTo(enabled);

    }



    @Test
@@ -206,76 +211,84 @@ public class UserManagerServiceUserInfoTest { 


    @Test

    public void testGetUserName() throws Exception {

        assertFalse("System user name shouldn't be set",

                mUserManagerService.isUserNameSet(UserHandle.USER_SYSTEM));

        expect.withMessage("System user name is set")

                .that(mUserManagerService.isUserNameSet(UserHandle.USER_SYSTEM)).isFalse();

        UserInfo userInfo = mUserManagerService.getUserInfo(UserHandle.USER_SYSTEM);

        assertFalse("A system provided name should be returned for primary user",

                TextUtils.isEmpty(userInfo.name));

        expect.withMessage("A system provided name returned for primary user is empty")

                .that(TextUtils.isEmpty(userInfo.name)).isFalse();



        userInfo = createUser();

        userInfo.partial = false;

        final int TEST_ID = 100;

        userInfo.id = TEST_ID;

        mUserManagerService.putUserInfo(userInfo);

        assertTrue("Test user name must be set", mUserManagerService.isUserNameSet(TEST_ID));

        assertEquals("A Name", mUserManagerService.getUserInfo(TEST_ID).name);

        expect.withMessage("user name is set").that(mUserManagerService.isUserNameSet(TEST_ID))

                .isTrue();

        expect.withMessage("name").that(mUserManagerService.getUserInfo(TEST_ID).name)

                .isEqualTo("A Name");

    }



    /** Test UMS.isUserOfType(). */

    @Test

    public void testIsUserOfType() throws Exception {

        assertTrue("System user was of invalid type",

        expect.withMessage("System user type is valid").that(

                mUserManagerService.isUserOfType(UserHandle.USER_SYSTEM, USER_TYPE_SYSTEM_HEADLESS)

                || mUserManagerService.isUserOfType(UserHandle.USER_SYSTEM, USER_TYPE_FULL_SYSTEM));

                        || mUserManagerService.isUserOfType(UserHandle.USER_SYSTEM,

                                USER_TYPE_FULL_SYSTEM))

                .isTrue();



        final int testId = 100;

        final String typeName = "A type";

        UserInfo userInfo = createUser(testId, 0, typeName);

        mUserManagerService.putUserInfo(userInfo);

        assertTrue(mUserManagerService.isUserOfType(testId, typeName));

        expect.withMessage("isUserOfType()")

                .that(mUserManagerService.isUserOfType(testId, typeName)).isTrue();

    }



    /** Test UserInfo.supportsSwitchTo() for partial user. */

    @Test

    public void testSupportSwitchTo_partial() throws Exception {

        UserInfo userInfo = createUser(100, FLAG_FULL, null);

        UserInfo userInfo = createUser(100, FLAG_FULL, /* userType= */ null);

        userInfo.partial = true;

        assertFalse("Switching to a partial user should be disabled",

                userInfo.supportsSwitchTo());

        expect.withMessage("Supports switch to a partial user").that(userInfo.supportsSwitchTo())

                .isFalse();

    }



    /** Test UserInfo.supportsSwitchTo() for disabled user. */

    @Test

    public void testSupportSwitchTo_disabled() throws Exception {

        UserInfo userInfo = createUser(100, FLAG_DISABLED, null);

        assertFalse("Switching to a DISABLED user should be disabled",

                userInfo.supportsSwitchTo());

        UserInfo userInfo = createUser(100, FLAG_DISABLED, /* userType= */ null);

        expect.withMessage("Supports switch to a DISABLED user").that(userInfo.supportsSwitchTo())

                .isFalse();

    }



    /** Test UserInfo.supportsSwitchTo() for precreated users. */

    @Test

    public void testSupportSwitchTo_preCreated() throws Exception {

        UserInfo userInfo = createUser(100, FLAG_FULL, null);

        UserInfo userInfo = createUser(100, FLAG_FULL, /* userType= */ null);

        userInfo.preCreated = true;

        assertFalse("Switching to a precreated user should be disabled",

                userInfo.supportsSwitchTo());

        expect.withMessage("Supports switch to a pre-created user")

                .that(userInfo.supportsSwitchTo())

                .isFalse();



        userInfo.preCreated = false;

        assertTrue("Switching to a full, real user should be allowed", userInfo.supportsSwitchTo());

        expect.withMessage("Supports switch to a full, real user").that(userInfo.supportsSwitchTo())

                .isTrue();

    }



    /** Test UserInfo.supportsSwitchTo() for profiles. */

    @Test

    public void testSupportSwitchTo_profile() throws Exception {

        UserInfo userInfo = createUser(100, FLAG_PROFILE, null);

        assertFalse("Switching to a profiles should be disabled", userInfo.supportsSwitchTo());

        UserInfo userInfo = createUser(100, FLAG_PROFILE, /* userType= */ null);

        expect.withMessage("Supports switch to a profile").that(userInfo.supportsSwitchTo())

                .isFalse();

    }



    /** Test UserInfo.canHaveProfile for main user */

    @Test

    public void testCanHaveProfile() throws Exception {

        UserInfo userInfo = createUser(100, FLAG_FULL | FLAG_MAIN, null);

        assertTrue("Main users can have profile", userInfo.canHaveProfile());

        UserInfo userInfo = createUser(100, FLAG_FULL | FLAG_MAIN, /* userType= */ null);

        expect.withMessage("Main users can have profile").that(userInfo.canHaveProfile()).isTrue();

    }



    /** Tests upgradeIfNecessaryLP (but without locking) for upgrading from version 8 to 9+. */
@@ -296,22 +309,32 @@ public class UserManagerServiceUserInfoTest { 


        mUserManagerService.upgradeIfNecessaryLP(versionToTest - 1, userTypeVersion);



        assertTrue(mUserManagerService.isUserOfType(100, USER_TYPE_PROFILE_MANAGED));

        assertTrue((mUserManagerService.getUserInfo(100).flags & FLAG_PROFILE) != 0);

        expect.withMessage("isUserOfType(100, USER_TYPE_PROFILE_MANAGED)")

                .that(mUserManagerService.isUserOfType(100, USER_TYPE_PROFILE_MANAGED)).isTrue();

        expect.withMessage("getUserInfo(100).flags & FLAG_PROFILE)")

                .that(mUserManagerService.getUserInfo(100).flags & FLAG_PROFILE).isNotEqualTo(0);



        assertTrue(mUserManagerService.isUserOfType(101, USER_TYPE_FULL_GUEST));

        expect.withMessage("isUserOfType(101, USER_TYPE_FULL_GUEST)")

                .that(mUserManagerService.isUserOfType(101, USER_TYPE_FULL_GUEST)).isTrue();



        assertTrue(mUserManagerService.isUserOfType(102, USER_TYPE_FULL_RESTRICTED));

        assertTrue((mUserManagerService.getUserInfo(102).flags & FLAG_PROFILE) == 0);

        expect.withMessage("isUserOfType(102, USER_TYPE_FULL_RESTRICTED)")

                .that(mUserManagerService.isUserOfType(102, USER_TYPE_FULL_RESTRICTED)).isTrue();

        expect.withMessage("getUserInfo(102).flags & FLAG_PROFILE)")

                .that(mUserManagerService.getUserInfo(102).flags & FLAG_PROFILE).isEqualTo(0);



        assertTrue(mUserManagerService.isUserOfType(103, USER_TYPE_FULL_SECONDARY));

        assertTrue((mUserManagerService.getUserInfo(103).flags & FLAG_PROFILE) == 0);

        expect.withMessage("isUserOfType(103, USER_TYPE_FULL_SECONDARY)")

                .that(mUserManagerService.isUserOfType(103, USER_TYPE_FULL_SECONDARY)).isTrue();

        expect.withMessage("getUserInfo(103).flags & FLAG_PROFILE)")

                .that(mUserManagerService.getUserInfo(103).flags & FLAG_PROFILE).isEqualTo(0);



        assertTrue(mUserManagerService.isUserOfType(104, USER_TYPE_SYSTEM_HEADLESS));

        expect.withMessage("isUserOfType(104, USER_TYPE_SYSTEM_HEADLESS)")

                .that(mUserManagerService.isUserOfType(104, USER_TYPE_SYSTEM_HEADLESS)).isTrue();



        assertTrue(mUserManagerService.isUserOfType(105, USER_TYPE_FULL_SYSTEM));

        expect.withMessage("isUserOfType(105, USER_TYPE_FULL_SYSTEM)")

                .that(mUserManagerService.isUserOfType(105, USER_TYPE_FULL_SYSTEM)).isTrue();



        assertTrue(mUserManagerService.isUserOfType(106, USER_TYPE_FULL_DEMO));

        expect.withMessage("isUserOfType(106, USER_TYPE_FULL_DEMO)")

                .that(mUserManagerService.isUserOfType(106, USER_TYPE_FULL_DEMO)).isTrue();

    }



    /** Tests readUserLP upgrading from version 9 to 10+. */
@@ -329,8 +352,11 @@ public class UserManagerServiceUserInfoTest { 
        mUserManagerService.putUserInfo(data.info);



        for (String restriction : localRestrictions) {

            assertFalse(mUserManagerService.hasBaseUserRestriction(restriction, userId));

            assertFalse(mUserManagerService.hasUserRestriction(restriction, userId));

            expect.withMessage("hasBaseUserRestriction(%s, %s)", restriction, userId)

                    .that(mUserManagerService.hasBaseUserRestriction(restriction, userId))

                    .isFalse();

            expect.withMessage("hasUserRestriction(%s, %s)", restriction, userId)

                    .that(mUserManagerService.hasUserRestriction(restriction, userId)).isFalse();

        }



        // Convert the xml resource to the system storage xml format.
@@ -348,8 +374,11 @@ public class UserManagerServiceUserInfoTest { 
                userVersion);



        for (String restriction : localRestrictions) {

            assertFalse(mUserManagerService.hasBaseUserRestriction(restriction, userId));

            assertTrue(mUserManagerService.hasUserRestriction(restriction, userId));

            expect.withMessage("hasBaseUserRestriction(%s, %s)", restriction, userId)

                    .that(mUserManagerService.hasBaseUserRestriction(restriction, userId))

                    .isFalse();

            expect.withMessage("hasUserRestriction(%s, %s)", restriction, userId)

                    .that(mUserManagerService.hasUserRestriction(restriction, userId)).isTrue();

        }

    }
@@ -375,24 +404,24 @@ public class UserManagerServiceUserInfoTest { 
    }



    private void assertUserInfoEquals(UserInfo one, UserInfo two, boolean parcelCopy) {

        assertEquals("Id not preserved", one.id, two.id);

        assertEquals("Name not preserved", one.name, two.name);

        assertEquals("Icon path not preserved", one.iconPath, two.iconPath);

        assertEquals("Flags not preserved", one.flags, two.flags);

        assertEquals("UserType not preserved", one.userType, two.userType);

        assertEquals("profile group not preserved", one.profileGroupId,

                two.profileGroupId);

        assertEquals("restricted profile parent not preserved", one.restrictedProfileParentId,

                two.restrictedProfileParentId);

        assertEquals("profile badge not preserved", one.profileBadge, two.profileBadge);

        assertEquals("partial not preserved", one.partial, two.partial);

        assertEquals("guestToRemove not preserved", one.guestToRemove, two.guestToRemove);

        assertEquals("preCreated not preserved", one.preCreated, two.preCreated);

        expect.withMessage("Id").that(two.id).isEqualTo(one.id);

        expect.withMessage("Name").that(two.name).isEqualTo(one.name);

        expect.withMessage("Icon path").that(two.iconPath).isEqualTo(one.iconPath);

        expect.withMessage("Flags").that(two.flags).isEqualTo(one.flags);

        expect.withMessage("User type").that(two.userType).isEqualTo(one.userType);

        expect.withMessage("Profile group").that(two.profileGroupId).isEqualTo(one.profileGroupId);

        expect.withMessage("Restricted profile parent").that(two.restrictedProfileParentId)

                .isEqualTo(one.restrictedProfileParentId);

        expect.withMessage("Profile badge").that(two.profileBadge).isEqualTo(one.profileBadge);

        expect.withMessage("Partial").that(two.partial).isEqualTo(one.partial);

        expect.withMessage("Guest to remove").that(two.guestToRemove).isEqualTo(one.guestToRemove);

        expect.withMessage("Pre created").that(two.preCreated).isEqualTo(one.preCreated);

        if (parcelCopy) {

            assertFalse("convertedFromPreCreated should not be set", two.convertedFromPreCreated);

            expect.withMessage("convertedFromPreCreated").that(two.convertedFromPreCreated)

                    .isFalse();

        } else {

            assertEquals("convertedFromPreCreated not preserved", one.convertedFromPreCreated,

                    two.convertedFromPreCreated);

            expect.withMessage("convertedFromPreCreated").that(two.convertedFromPreCreated)

                    .isEqualTo(one.convertedFromPreCreated);

        }

    }
@@ -428,10 +457,16 @@ public class UserManagerServiceUserInfoTest { 


        mUserManagerService.upgradeProfileToTypeLU(userInfo, newUserType);



        assertTrue(mUserManagerService.isUserOfType(userId, newUserTypeName));

        assertTrue((mUserManagerService.getUserInfo(userId).flags & FLAG_PROFILE) != 0);

        assertTrue((mUserManagerService.getUserInfo(userId).flags & FLAG_MANAGED_PROFILE) == 0);

        assertTrue((mUserManagerService.getUserInfo(userId).flags & FLAG_INITIALIZED) != 0);

        expect.withMessage("isUserOfType(%s)", newUserTypeName)

                .that(mUserManagerService.isUserOfType(userId, newUserTypeName)).isTrue();

        expect.withMessage("flags(FLAG_PROFILE)")

                .that(mUserManagerService.getUserInfo(userId).flags & FLAG_PROFILE).isNotEqualTo(0);

        expect.withMessage("flags(FLAG_MANAGED_PROFILE)")

                .that(mUserManagerService.getUserInfo(userId).flags & FLAG_MANAGED_PROFILE)

                .isEqualTo(0);

        expect.withMessage("flags(FLAG_FLAG_INITIALIZED")

                .that(mUserManagerService.getUserInfo(userId).flags & FLAG_INITIALIZED)

                .isNotEqualTo(0);

    }



    @Test
@@ -470,11 +505,11 @@ public class UserManagerServiceUserInfoTest { 


        mUserManagerService.upgradeProfileToTypeLU(userInfo, newUserType);



        assertTrue(mUserManagerService.getUserRestrictions(userId).getBoolean(

                UserManager.DISALLOW_PRINTING));

        assertTrue(mUserManagerService.getUserRestrictions(userId).getBoolean(

                UserManager.DISALLOW_CAMERA));

        assertTrue(mUserManagerService.getUserRestrictions(userId).getBoolean(

                UserManager.DISALLOW_WALLPAPER));

        expect.withMessage("getUserRestrictions(DISALLOW_PRINTING)").that(mUserManagerService

                .getUserRestrictions(userId).getBoolean(UserManager.DISALLOW_PRINTING)).isTrue();

        expect.withMessage("getUserRestrictions(DISALLOW_CAMERA)").that(mUserManagerService

                .getUserRestrictions(userId).getBoolean(UserManager.DISALLOW_CAMERA)).isTrue();

        expect.withMessage("getUserRestrictions(DISALLOW_WALLPAPER)").that(mUserManagerService

                .getUserRestrictions(userId).getBoolean(UserManager.DISALLOW_WALLPAPER)).isTrue();

    }

}