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

Commit 3abfcd59 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "OMS: Assert which packages are updated" into sc-dev

parents f773a1e4 60f91228

services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplRebootTests.java

+84 −75
Original line number Diff line number Diff line
@@ -23,15 +23,14 @@ import static org.junit.Assert.assertTrue; 


import android.content.om.OverlayIdentifier;

import android.content.om.OverlayInfo;

import android.util.ArraySet;



import androidx.test.runner.AndroidJUnit4;



import org.junit.Test;

import org.junit.runner.RunWith;



import java.util.Arrays;

import java.util.function.BiConsumer;

import java.util.Set;

import java.util.function.Consumer;



@RunWith(AndroidJUnit4.class)

public class OverlayManagerServiceImplRebootTests extends OverlayManagerServiceImplTestsBase {
@@ -45,51 +44,47 @@ public class OverlayManagerServiceImplRebootTests extends OverlayManagerServiceI 
    private static final OverlayIdentifier IDENTIFIER2 = new OverlayIdentifier(OVERLAY2);



    @Test

    public void testUpdateOverlaysForUser() {

    public void alwaysInitializeAllPackages() {

        final OverlayManagerServiceImpl impl = getImpl();

        final String otherTarget = "some.other.target";

        addPackage(target(TARGET), USER);

        addPackage(target(otherTarget), USER);

        addPackage(overlay(OVERLAY, TARGET), USER);



        // do nothing, expect no change

        final ArraySet<PackageAndUser> a = impl.updateOverlaysForUser(USER);

        assertEquals(3, a.size());

        assertTrue(a.containsAll(Arrays.asList(

                new PackageAndUser(TARGET, USER),

        final Set<PackageAndUser> allPackages =

                Set.of(new PackageAndUser(TARGET, USER),

                        new PackageAndUser(otherTarget, USER),

                new PackageAndUser(OVERLAY, USER))));

                        new PackageAndUser(OVERLAY, USER));



        final ArraySet<PackageAndUser> b = impl.updateOverlaysForUser(USER);

        assertEquals(3, b.size());

        assertTrue(b.containsAll(Arrays.asList(

                new PackageAndUser(TARGET, USER),

                new PackageAndUser(otherTarget, USER),

                new PackageAndUser(OVERLAY, USER))));

        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

    }



    @Test

    public void testImmutableEnabledChange() throws Exception {

    public void testImmutableEnabledChange() {

        final OverlayManagerServiceImpl impl = getImpl();

        installPackage(target(TARGET), USER);

        installPackage(overlay(OVERLAY, TARGET), USER);

        addPackage(target(TARGET), USER);

        addPackage(overlay(OVERLAY, TARGET), USER);



        configureSystemOverlay(OVERLAY, false /* mutable */, false /* enabled */, 0 /* priority */);

        impl.updateOverlaysForUser(USER);

        final Set<PackageAndUser> allPackages =

                Set.of(new PackageAndUser(TARGET, USER), new PackageAndUser(OVERLAY, USER));



        configureSystemOverlay(OVERLAY, ConfigState.IMMUTABLE_DISABLED, 0 /* priority */);

        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

        final OverlayInfo o1 = impl.getOverlayInfo(IDENTIFIER, USER);

        assertNotNull(o1);

        assertFalse(o1.isEnabled());

        assertFalse(o1.isMutable);



        configureSystemOverlay(OVERLAY, false /* mutable */, true /* enabled */, 0 /* priority */);

        impl.updateOverlaysForUser(USER);

        configureSystemOverlay(OVERLAY, ConfigState.IMMUTABLE_ENABLED, 0 /* priority */);

        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

        final OverlayInfo o2 = impl.getOverlayInfo(IDENTIFIER, USER);

        assertNotNull(o2);

        assertTrue(o2.isEnabled());

        assertFalse(o2.isMutable);



        configureSystemOverlay(OVERLAY, false /* mutable */, false /* enabled */, 0 /* priority */);

        impl.updateOverlaysForUser(USER);

        configureSystemOverlay(OVERLAY, ConfigState.IMMUTABLE_DISABLED, 0 /* priority */);

        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

        final OverlayInfo o3 = impl.getOverlayInfo(IDENTIFIER, USER);

        assertNotNull(o3);

        assertFalse(o3.isEnabled());
@@ -97,27 +92,30 @@ public class OverlayManagerServiceImplRebootTests extends OverlayManagerServiceI 
    }



    @Test

    public void testMutableEnabledChangeHasNoEffect() throws Exception {

    public void testMutableEnabledChangeHasNoEffect() {

        final OverlayManagerServiceImpl impl = getImpl();

        installPackage(target(TARGET), USER);

        installPackage(overlay(OVERLAY, TARGET), USER);

        configureSystemOverlay(OVERLAY, true /* mutable */, false /* enabled */, 0 /* priority */);

        addPackage(target(TARGET), USER);

        addPackage(overlay(OVERLAY, TARGET), USER);

        configureSystemOverlay(OVERLAY, ConfigState.MUTABLE_DISABLED, 0 /* priority */);



        final Set<PackageAndUser> allPackages =

                Set.of(new PackageAndUser(TARGET, USER), new PackageAndUser(OVERLAY, USER));



        impl.updateOverlaysForUser(USER);

        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

        final OverlayInfo o1 = impl.getOverlayInfo(IDENTIFIER, USER);

        assertNotNull(o1);

        assertFalse(o1.isEnabled());

        assertTrue(o1.isMutable);



        configureSystemOverlay(OVERLAY, true /* mutable */, true /* enabled */, 0 /* priority */);

        impl.updateOverlaysForUser(USER);

        configureSystemOverlay(OVERLAY, ConfigState.MUTABLE_ENABLED, 0 /* priority */);

        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

        final OverlayInfo o2 = impl.getOverlayInfo(IDENTIFIER, USER);

        assertNotNull(o2);

        assertFalse(o2.isEnabled());

        assertTrue(o2.isMutable);



        configureSystemOverlay(OVERLAY, true /* mutable */, false /* enabled */, 0 /* priority */);

        impl.updateOverlaysForUser(USER);

        configureSystemOverlay(OVERLAY, ConfigState.MUTABLE_DISABLED, 0 /* priority */);

        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

        final OverlayInfo o3 = impl.getOverlayInfo(IDENTIFIER, USER);

        assertNotNull(o3);

        assertFalse(o3.isEnabled());
@@ -125,59 +123,68 @@ public class OverlayManagerServiceImplRebootTests extends OverlayManagerServiceI 
    }



    @Test

    public void testMutableEnabledToImmutableEnabled() throws Exception {

    public void testMutableEnabledToImmutableEnabled() {

        final OverlayManagerServiceImpl impl = getImpl();

        installPackage(target(TARGET), USER);

        installPackage(overlay(OVERLAY, TARGET), USER);

        addPackage(target(TARGET), USER);

        addPackage(overlay(OVERLAY, TARGET), USER);



        final BiConsumer<Boolean, Boolean> setOverlay = (mutable, enabled) -> {

            configureSystemOverlay(OVERLAY, mutable, enabled, 0 /* priority */);

            impl.updateOverlaysForUser(USER);

        final Set<PackageAndUser> allPackages =

                Set.of(new PackageAndUser(TARGET, USER), new PackageAndUser(OVERLAY, USER));



        final Consumer<ConfigState> setOverlay = (state -> {

            configureSystemOverlay(OVERLAY, state, 0 /* priority */);

            assertEquals(allPackages, impl.updateOverlaysForUser(USER));

            final OverlayInfo o = impl.getOverlayInfo(IDENTIFIER, USER);

            assertNotNull(o);

            assertEquals(enabled, o.isEnabled());

            assertEquals(mutable, o.isMutable);

        };

            assertEquals(o.isEnabled(), state == ConfigState.IMMUTABLE_ENABLED

                    || state == ConfigState.MUTABLE_ENABLED);

            assertEquals(o.isMutable, state == ConfigState.MUTABLE_DISABLED

                    || state == ConfigState.MUTABLE_ENABLED);

        });



        // Immutable/enabled -> mutable/enabled

        setOverlay.accept(false /* mutable */, true /* enabled */);

        setOverlay.accept(true /* mutable */, true /* enabled */);

        setOverlay.accept(ConfigState.IMMUTABLE_ENABLED);

        setOverlay.accept(ConfigState.MUTABLE_ENABLED);



        // Mutable/enabled -> immutable/enabled

        setOverlay.accept(false /* mutable */, true /* enabled */);

        setOverlay.accept(ConfigState.IMMUTABLE_ENABLED);



        // Immutable/enabled -> mutable/disabled

        setOverlay.accept(true /* mutable */, false /* enabled */);

        setOverlay.accept(ConfigState.MUTABLE_DISABLED);



        // Mutable/disabled -> immutable/enabled

        setOverlay.accept(false /* mutable */, true /* enabled */);

        setOverlay.accept(ConfigState.IMMUTABLE_ENABLED);



        // Immutable/enabled -> immutable/disabled

        setOverlay.accept(false /* mutable */, false /* enabled */);

        setOverlay.accept(ConfigState.IMMUTABLE_DISABLED);



        // Immutable/disabled -> mutable/enabled

        setOverlay.accept(true /* mutable */, true /* enabled */);

        setOverlay.accept(ConfigState.MUTABLE_ENABLED);



        // Mutable/enabled -> immutable/disabled

        setOverlay.accept(false /* mutable */, false /* enabled */);

        setOverlay.accept(ConfigState.IMMUTABLE_DISABLED);



        // Immutable/disabled -> mutable/disabled

        setOverlay.accept(true /* mutable */, false /* enabled */);

        setOverlay.accept(ConfigState.MUTABLE_DISABLED);



        // Mutable/disabled -> immutable/disabled

        setOverlay.accept(false /* mutable */, false /* enabled */);

        setOverlay.accept(ConfigState.IMMUTABLE_DISABLED);

    }



    @Test

    public void testMutablePriorityChange() throws Exception {

        final OverlayManagerServiceImpl impl = getImpl();

        installPackage(target(TARGET), USER);

        installPackage(overlay(OVERLAY, TARGET), USER);

        installPackage(overlay(OVERLAY2, TARGET), USER);

        configureSystemOverlay(OVERLAY, true /* mutable */, false /* enabled */, 0 /* priority */);

        configureSystemOverlay(OVERLAY2, true /* mutable */, false /* enabled */, 1 /* priority */);

        impl.updateOverlaysForUser(USER);

        addPackage(target(TARGET), USER);

        addPackage(overlay(OVERLAY, TARGET), USER);

        addPackage(overlay(OVERLAY2, TARGET), USER);

        configureSystemOverlay(OVERLAY, ConfigState.MUTABLE_DISABLED, 0 /* priority */);

        configureSystemOverlay(OVERLAY2, ConfigState.MUTABLE_DISABLED, 1 /* priority */);



        final Set<PackageAndUser> allPackages =

                Set.of(new PackageAndUser(TARGET, USER), new PackageAndUser(OVERLAY, USER),

                        new PackageAndUser(OVERLAY2, USER));



        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

        final OverlayInfo o1 = impl.getOverlayInfo(IDENTIFIER, USER);

        assertNotNull(o1);

        assertEquals(0, o1.priority);
@@ -193,10 +200,9 @@ public class OverlayManagerServiceImplRebootTests extends OverlayManagerServiceI 
        impl.setEnabled(IDENTIFIER, true, USER);



        // Reorder the overlays

        configureSystemOverlay(OVERLAY, true /* mutable */, false /* enabled */, 1 /* priority */);

        configureSystemOverlay(OVERLAY2, true /* mutable */, false /* enabled */, 0 /* priority */);

        impl.updateOverlaysForUser(USER);



        configureSystemOverlay(OVERLAY, ConfigState.MUTABLE_DISABLED, 1 /* priority */);

        configureSystemOverlay(OVERLAY2, ConfigState.MUTABLE_DISABLED, 0 /* priority */);

        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

        final OverlayInfo o3 = impl.getOverlayInfo(IDENTIFIER, USER);

        assertNotNull(o3);

        assertEquals(1, o3.priority);
@@ -211,13 +217,17 @@ public class OverlayManagerServiceImplRebootTests extends OverlayManagerServiceI 
    @Test

    public void testImmutablePriorityChange() throws Exception {

        final OverlayManagerServiceImpl impl = getImpl();

        installPackage(target(TARGET), USER);

        installPackage(overlay(OVERLAY, TARGET), USER);

        installPackage(overlay(OVERLAY2, TARGET), USER);

        configureSystemOverlay(OVERLAY, false /* mutable */, true /* enabled */, 0 /* priority */);

        configureSystemOverlay(OVERLAY2, false /* mutable */, true /* enabled */, 1 /* priority */);

        impl.updateOverlaysForUser(USER);

        addPackage(target(TARGET), USER);

        addPackage(overlay(OVERLAY, TARGET), USER);

        addPackage(overlay(OVERLAY2, TARGET), USER);

        configureSystemOverlay(OVERLAY, ConfigState.IMMUTABLE_ENABLED, 0 /* priority */);

        configureSystemOverlay(OVERLAY2, ConfigState.IMMUTABLE_ENABLED, 1 /* priority */);



        final Set<PackageAndUser> allPackages =

                Set.of(new PackageAndUser(TARGET, USER), new PackageAndUser(OVERLAY, USER),

                        new PackageAndUser(OVERLAY2, USER));



        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

        final OverlayInfo o1 = impl.getOverlayInfo(IDENTIFIER, USER);

        assertNotNull(o1);

        assertEquals(0, o1.priority);
@@ -229,10 +239,9 @@ public class OverlayManagerServiceImplRebootTests extends OverlayManagerServiceI 
        assertTrue(o2.isEnabled());



        // Reorder the overlays

        configureSystemOverlay(OVERLAY, false /* mutable */, true /* enabled */, 1 /* priority */);

        configureSystemOverlay(OVERLAY2, false /* mutable */, true /* enabled */, 0 /* priority */);

        impl.updateOverlaysForUser(USER);



        configureSystemOverlay(OVERLAY, ConfigState.IMMUTABLE_ENABLED, 1 /* priority */);

        configureSystemOverlay(OVERLAY2, ConfigState.IMMUTABLE_ENABLED, 0 /* priority */);

        assertEquals(allPackages, impl.updateOverlaysForUser(USER));

        final OverlayInfo o3 = impl.getOverlayInfo(IDENTIFIER, USER);

        assertNotNull(o3);

        assertEquals(1, o3.priority);

services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplTests.java

+82 −55

File changed.

Preview size limit exceeded, changes collapsed.

services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplTestsBase.java

+25 −17
Original line number Diff line number Diff line
@@ -139,8 +139,19 @@ class OverlayManagerServiceImplTestsBase { 
        mState.add(pkg, userId);

    }



    void configureSystemOverlay(String packageName, boolean mutable, boolean enabled,

    enum ConfigState {

        IMMUTABLE_DISABLED,

        IMMUTABLE_ENABLED,

        MUTABLE_DISABLED,

        MUTABLE_ENABLED

    }



    void configureSystemOverlay(@NonNull String packageName, @NonNull ConfigState state,

            int priority) {

        final boolean mutable = state == ConfigState.MUTABLE_DISABLED

                || state == ConfigState.MUTABLE_ENABLED;

        final boolean enabled = state == ConfigState.IMMUTABLE_ENABLED

                || state == ConfigState.MUTABLE_ENABLED;

        when(mOverlayConfig.getPriority(packageName)).thenReturn(priority);

        when(mOverlayConfig.isEnabled(packageName)).thenReturn(enabled);

        when(mOverlayConfig.isMutable(packageName)).thenReturn(mutable);
@@ -154,13 +165,14 @@ class OverlayManagerServiceImplTestsBase { 
     *

     * @throws IllegalStateException if the package is currently installed

     */

    Set<PackageAndUser> installPackage(FakeDeviceState.PackageBuilder pkg, int userId)

    void installAndAssert(@NonNull FakeDeviceState.PackageBuilder pkg, int userId,

            @NonNull Set<PackageAndUser> onAddedUpdatedPackages)

            throws OperationFailedException {

        if (mState.select(pkg.packageName, userId) != null) {

            throw new IllegalStateException("package " + pkg.packageName + " already installed");

        }

        mState.add(pkg, userId);

        return CollectionUtils.emptyIfNull(mImpl.onPackageAdded(pkg.packageName, userId));

        assertEquals(onAddedUpdatedPackages, mImpl.onPackageAdded(pkg.packageName, userId));

    }



    /**
@@ -172,25 +184,20 @@ class OverlayManagerServiceImplTestsBase { 
     * {@link android.content.Intent#ACTION_PACKAGE_ADDED} broadcast with the

     * {@link android.content.Intent#EXTRA_REPLACING} extra.

     *

     * @return the two Optional<PackageAndUser> objects from starting and finishing the upgrade

     *

     * @throws IllegalStateException if the package is not currently installed

     */

    Pair<Set<PackageAndUser>, Set<PackageAndUser>> upgradePackage(

            FakeDeviceState.PackageBuilder pkg, int userId) throws OperationFailedException {

    void upgradeAndAssert(FakeDeviceState.PackageBuilder pkg, int userId,

            @NonNull Set<PackageAndUser> onReplacingUpdatedPackages,

            @NonNull Set<PackageAndUser> onReplacedUpdatedPackages)

            throws OperationFailedException {

        final FakeDeviceState.Package replacedPackage = mState.select(pkg.packageName, userId);

        if (replacedPackage == null) {

            throw new IllegalStateException("package " + pkg.packageName + " not installed");

        }



        final Set<PackageAndUser> updatedPackages1 =

                CollectionUtils.emptyIfNull(mImpl.onPackageReplacing(pkg.packageName, userId));



        assertEquals(onReplacingUpdatedPackages, mImpl.onPackageReplacing(pkg.packageName, userId));

        mState.add(pkg, userId);

        final Set<PackageAndUser> updatedPackages2 =

                CollectionUtils.emptyIfNull(mImpl.onPackageReplaced(pkg.packageName, userId));



        return Pair.create(updatedPackages1, updatedPackages2);

        assertEquals(onReplacedUpdatedPackages, mImpl.onPackageReplaced(pkg.packageName, userId));

    }



    /**
@@ -201,13 +208,14 @@ class OverlayManagerServiceImplTestsBase { 
     *

     * @throws IllegalStateException if the package is not currently installed

     */

    Set<PackageAndUser> uninstallPackage(String packageName, int userId) {

    void uninstallAndAssert(@NonNull String packageName, int userId,

            @NonNull Set<PackageAndUser> onRemovedUpdatedPackages) {

        final FakeDeviceState.Package pkg = mState.select(packageName, userId);

        if (pkg == null) {

            throw new IllegalStateException("package " + packageName + " not installed");

        }

        mState.remove(pkg.packageName);

        return CollectionUtils.emptyIfNull(mImpl.onPackageRemoved(packageName, userId));

        assertEquals(onRemovedUpdatedPackages, mImpl.onPackageRemoved(pkg.packageName, userId));

    }



    /** Represents the state of packages installed on a fake device. */