From 60f912286de77feb1f68815302247153b99270d5 Mon Sep 17 00:00:00 2001 From: Ryan Mitchell Date: Wed, 17 Feb 2021 11:30:36 -0800 Subject: [PATCH] OMS: Assert which packages are updated When the overlay manager is initialized and when packages are installed, upgraded, or removed, the overlay manager must report any updates to the currently enabled overlays for each package to PMS. Test that when a package event happens, all packages that may have their overlays affected are returned as updated packages from the OMSImpl event methods. Bug: 180016597 Test: atest Change-Id: I9906f8805a2c2728e8c8b57ab9990b169ef06a2d --- .../OverlayManagerServiceImplRebootTests.java | 157 +++++++++--------- .../om/OverlayManagerServiceImplTests.java | 137 +++++++++------ .../OverlayManagerServiceImplTestsBase.java | 42 +++-- 3 files changed, 190 insertions(+), 146 deletions(-) diff --git a/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplRebootTests.java b/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplRebootTests.java index 55cd772ad7e07..94e67d16acab9 100644 --- a/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplRebootTests.java +++ b/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplRebootTests.java @@ -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 a = impl.updateOverlaysForUser(USER); - assertEquals(3, a.size()); - assertTrue(a.containsAll(Arrays.asList( - new PackageAndUser(TARGET, USER), - new PackageAndUser(otherTarget, USER), - new PackageAndUser(OVERLAY, USER)))); + final Set allPackages = + Set.of(new PackageAndUser(TARGET, USER), + new PackageAndUser(otherTarget, USER), + new PackageAndUser(OVERLAY, USER)); - final ArraySet 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 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 */); - impl.updateOverlaysForUser(USER); + final Set allPackages = + Set.of(new PackageAndUser(TARGET, USER), new PackageAndUser(OVERLAY, 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 setOverlay = (mutable, enabled) -> { - configureSystemOverlay(OVERLAY, mutable, enabled, 0 /* priority */); - impl.updateOverlaysForUser(USER); + final Set allPackages = + Set.of(new PackageAndUser(TARGET, USER), new PackageAndUser(OVERLAY, USER)); + + final Consumer 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 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 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); diff --git a/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplTests.java b/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplTests.java index 45f82a36c8ed8..f69141db0872c 100644 --- a/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplTests.java +++ b/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplTests.java @@ -65,7 +65,8 @@ public class OverlayManagerServiceImplTests extends OverlayManagerServiceImplTes @Test public void testGetOverlayInfo() throws Exception { - installPackage(overlay(OVERLAY, TARGET), USER); + installAndAssert(overlay(OVERLAY, TARGET), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); final OverlayManagerServiceImpl impl = getImpl(); final OverlayInfo oi = impl.getOverlayInfo(IDENTIFIER, USER); @@ -77,9 +78,12 @@ public class OverlayManagerServiceImplTests extends OverlayManagerServiceImplTes @Test public void testGetOverlayInfosForTarget() throws Exception { - installPackage(overlay(OVERLAY, TARGET), USER); - installPackage(overlay(OVERLAY2, TARGET), USER); - installPackage(overlay(OVERLAY3, TARGET), USER2); + installAndAssert(overlay(OVERLAY, TARGET), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY2, TARGET), USER, + Set.of(new PackageAndUser(OVERLAY2, USER), new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY3, TARGET), USER2, + Set.of(new PackageAndUser(OVERLAY3, USER2), new PackageAndUser(TARGET, USER2))); final OverlayManagerServiceImpl impl = getImpl(); final List ois = impl.getOverlayInfosForTarget(TARGET, USER); @@ -102,10 +106,14 @@ public class OverlayManagerServiceImplTests extends OverlayManagerServiceImplTes @Test public void testGetOverlayInfosForUser() throws Exception { - installPackage(target(TARGET), USER); - installPackage(overlay(OVERLAY, TARGET), USER); - installPackage(overlay(OVERLAY2, TARGET), USER); - installPackage(overlay(OVERLAY3, TARGET2), USER); + installAndAssert(target(TARGET), USER, + Set.of(new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY, TARGET), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY2, TARGET), USER, + Set.of(new PackageAndUser(OVERLAY2, USER), new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY3, TARGET2), USER, + Set.of(new PackageAndUser(OVERLAY3, USER), new PackageAndUser(TARGET2, USER))); final OverlayManagerServiceImpl impl = getImpl(); final Map> everything = impl.getOverlaysForUser(USER); @@ -129,9 +137,12 @@ public class OverlayManagerServiceImplTests extends OverlayManagerServiceImplTes @Test public void testPriority() throws Exception { - installPackage(overlay(OVERLAY, TARGET), USER); - installPackage(overlay(OVERLAY2, TARGET), USER); - installPackage(overlay(OVERLAY3, TARGET), USER); + installAndAssert(overlay(OVERLAY, TARGET), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY2, TARGET), USER, + Set.of(new PackageAndUser(OVERLAY2, USER), new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY3, TARGET), USER, + Set.of(new PackageAndUser(OVERLAY3, USER), new PackageAndUser(TARGET, USER))); final OverlayManagerServiceImpl impl = getImpl(); final OverlayInfo o1 = impl.getOverlayInfo(IDENTIFIER, USER); @@ -158,11 +169,12 @@ public class OverlayManagerServiceImplTests extends OverlayManagerServiceImplTes final OverlayManagerServiceImpl impl = getImpl(); assertNull(impl.getOverlayInfo(IDENTIFIER, USER)); - installPackage(overlay(OVERLAY, TARGET), USER); + installAndAssert(overlay(OVERLAY, TARGET), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); assertState(STATE_MISSING_TARGET, IDENTIFIER, USER); - final FakeDeviceState.PackageBuilder target = target(TARGET); - installPackage(target, USER); + installAndAssert(target(TARGET), USER, + Set.of(new PackageAndUser(TARGET, USER))); assertState(STATE_DISABLED, IDENTIFIER, USER); assertEquals(impl.setEnabled(IDENTIFIER, true, USER), @@ -170,32 +182,35 @@ public class OverlayManagerServiceImplTests extends OverlayManagerServiceImplTes assertState(STATE_ENABLED, IDENTIFIER, USER); // target upgrades do not change the state of the overlay - upgradePackage(target, USER); + upgradeAndAssert(target(TARGET), USER, + Set.of(new PackageAndUser(TARGET, USER)), + Set.of(new PackageAndUser(TARGET, USER))); assertState(STATE_ENABLED, IDENTIFIER, USER); - uninstallPackage(TARGET, USER); + uninstallAndAssert(TARGET, USER, + Set.of(new PackageAndUser(TARGET, USER))); assertState(STATE_MISSING_TARGET, IDENTIFIER, USER); - installPackage(target, USER); + installAndAssert(target(TARGET), USER, + Set.of(new PackageAndUser(TARGET, USER))); assertState(STATE_ENABLED, IDENTIFIER, USER); } @Test public void testOnOverlayPackageUpgraded() throws Exception { - final FakeDeviceState.PackageBuilder target = target(TARGET); - final FakeDeviceState.PackageBuilder overlay = overlay(OVERLAY, TARGET); - installPackage(target, USER); - installPackage(overlay, USER); - upgradePackage(overlay, USER); + installAndAssert(target(TARGET), USER, + Set.of(new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY, TARGET), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); + upgradeAndAssert(overlay(OVERLAY, TARGET), USER, + Set.of(new PackageAndUser(TARGET, USER)), + Set.of(new PackageAndUser(TARGET, USER))); // upgrade to a version where the overlay has changed its target - final FakeDeviceState.PackageBuilder overlay2 = overlay(OVERLAY, "some.other.target"); - final Pair, Set> pair = upgradePackage(overlay2, USER); - assertEquals(pair.first, Set.of(new PackageAndUser(TARGET, USER))); - assertEquals( + upgradeAndAssert(overlay(OVERLAY, TARGET2), USER, + Set.of(new PackageAndUser(TARGET, USER)), Set.of(new PackageAndUser(TARGET, USER), - new PackageAndUser("some.other.target", USER)), - pair.second); + new PackageAndUser(TARGET2, USER))); } @Test @@ -206,13 +221,15 @@ public class OverlayManagerServiceImplTests extends OverlayManagerServiceImplTes // request succeeded, and there was a change that needs to be // propagated to the rest of the system - installPackage(target(TARGET), USER); - installPackage(overlay(OVERLAY, TARGET), USER); - assertEquals(impl.setEnabled(IDENTIFIER, true, USER), + installAndAssert(target(TARGET), USER, Set.of(new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY, TARGET), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); + assertEquals(Set.of(new PackageAndUser(TARGET, USER)), + impl.setEnabled(IDENTIFIER, true, USER)); // request succeeded, but nothing changed - assertTrue(impl.setEnabled(IDENTIFIER, true, USER).isEmpty()); + assertEquals(Set.of(), impl.setEnabled(IDENTIFIER, true, USER)); } @Test @@ -221,16 +238,18 @@ public class OverlayManagerServiceImplTests extends OverlayManagerServiceImplTes reinitializeImpl(); addPackage(target(CONFIG_SIGNATURE_REFERENCE_PKG).setCertificate(CERT_CONFIG_OK), USER); - installPackage(target(TARGET), USER); - installPackage(overlay(OVERLAY, TARGET).setCertificate(CERT_CONFIG_OK), USER); + installAndAssert(target(TARGET), USER, + Set.of(new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY, TARGET).setCertificate(CERT_CONFIG_OK), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); final FakeIdmapDaemon idmapd = getIdmapd(); final FakeDeviceState state = getState(); - String overlayPath = state.select(OVERLAY, USER).apkPath; + final String overlayPath = state.select(OVERLAY, USER).apkPath; assertTrue(idmapd.idmapExists(overlayPath, USER)); - FakeIdmapDaemon.IdmapHeader idmap = idmapd.getIdmap(overlayPath); - assertTrue((CONFIG_SIGNATURE & idmap.policies) == CONFIG_SIGNATURE); + final FakeIdmapDaemon.IdmapHeader idmap = idmapd.getIdmap(overlayPath); + assertEquals(CONFIG_SIGNATURE, CONFIG_SIGNATURE & idmap.policies); } @Test @@ -239,45 +258,51 @@ public class OverlayManagerServiceImplTests extends OverlayManagerServiceImplTes reinitializeImpl(); addPackage(target(CONFIG_SIGNATURE_REFERENCE_PKG).setCertificate(CERT_CONFIG_OK), USER); - installPackage(target(TARGET), USER); - installPackage(overlay(OVERLAY, TARGET).setCertificate(CERT_CONFIG_NOK), USER); + installAndAssert(target(TARGET), USER, + Set.of(new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY, TARGET).setCertificate(CERT_CONFIG_NOK), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); final FakeIdmapDaemon idmapd = getIdmapd(); final FakeDeviceState state = getState(); - String overlayPath = state.select(OVERLAY, USER).apkPath; + final String overlayPath = state.select(OVERLAY, USER).apkPath; assertTrue(idmapd.idmapExists(overlayPath, USER)); - FakeIdmapDaemon.IdmapHeader idmap = idmapd.getIdmap(overlayPath); - assertTrue((CONFIG_SIGNATURE & idmap.policies) == 0); + final FakeIdmapDaemon.IdmapHeader idmap = idmapd.getIdmap(overlayPath); + assertEquals(0, CONFIG_SIGNATURE & idmap.policies); } @Test public void testConfigSignaturePolicyNoConfig() throws Exception { addPackage(target(CONFIG_SIGNATURE_REFERENCE_PKG).setCertificate(CERT_CONFIG_OK), USER); - installPackage(target(TARGET), USER); - installPackage(overlay(OVERLAY, TARGET).setCertificate(CERT_CONFIG_NOK), USER); + installAndAssert(target(TARGET), USER, + Set.of(new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY, TARGET).setCertificate(CERT_CONFIG_NOK), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); final FakeIdmapDaemon idmapd = getIdmapd(); final FakeDeviceState state = getState(); - String overlayPath = state.select(OVERLAY, USER).apkPath; + final String overlayPath = state.select(OVERLAY, USER).apkPath; assertTrue(idmapd.idmapExists(overlayPath, USER)); - FakeIdmapDaemon.IdmapHeader idmap = idmapd.getIdmap(overlayPath); - assertTrue((CONFIG_SIGNATURE & idmap.policies) == 0); + final FakeIdmapDaemon.IdmapHeader idmap = idmapd.getIdmap(overlayPath); + assertEquals(0, CONFIG_SIGNATURE & idmap.policies); } @Test public void testConfigSignaturePolicyNoRefPkg() throws Exception { - installPackage(target(TARGET), USER); - installPackage(overlay(OVERLAY, TARGET).setCertificate(CERT_CONFIG_NOK), USER); + installAndAssert(target(TARGET), USER, + Set.of(new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY, TARGET).setCertificate(CERT_CONFIG_NOK), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); final FakeIdmapDaemon idmapd = getIdmapd(); final FakeDeviceState state = getState(); - String overlayPath = state.select(OVERLAY, USER).apkPath; + final String overlayPath = state.select(OVERLAY, USER).apkPath; assertTrue(idmapd.idmapExists(overlayPath, USER)); - FakeIdmapDaemon.IdmapHeader idmap = idmapd.getIdmap(overlayPath); - assertTrue((CONFIG_SIGNATURE & idmap.policies) == 0); + final FakeIdmapDaemon.IdmapHeader idmap = idmapd.getIdmap(overlayPath); + assertEquals(0, CONFIG_SIGNATURE & idmap.policies); } @Test @@ -286,8 +311,10 @@ public class OverlayManagerServiceImplTests extends OverlayManagerServiceImplTes reinitializeImpl(); addPackage(app(CONFIG_SIGNATURE_REFERENCE_PKG).setCertificate(CERT_CONFIG_OK), USER); - installPackage(target(TARGET), USER); - installPackage(overlay(OVERLAY, TARGET).setCertificate(CERT_CONFIG_NOK), USER); + installAndAssert(target(TARGET), USER, + Set.of(new PackageAndUser(TARGET, USER))); + installAndAssert(overlay(OVERLAY, TARGET).setCertificate(CERT_CONFIG_NOK), USER, + Set.of(new PackageAndUser(OVERLAY, USER), new PackageAndUser(TARGET, USER))); final FakeIdmapDaemon idmapd = getIdmapd(); final FakeDeviceState state = getState(); @@ -295,6 +322,6 @@ public class OverlayManagerServiceImplTests extends OverlayManagerServiceImplTes assertTrue(idmapd.idmapExists(overlayPath, USER)); FakeIdmapDaemon.IdmapHeader idmap = idmapd.getIdmap(overlayPath); - assertTrue((CONFIG_SIGNATURE & idmap.policies) == 0); + assertEquals(0, CONFIG_SIGNATURE & idmap.policies); } } diff --git a/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplTestsBase.java b/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplTestsBase.java index 16e03290b1e4a..29ff9f4c282c1 100644 --- a/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplTestsBase.java +++ b/services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplTestsBase.java @@ -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 installPackage(FakeDeviceState.PackageBuilder pkg, int userId) + void installAndAssert(@NonNull FakeDeviceState.PackageBuilder pkg, int userId, + @NonNull Set 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 objects from starting and finishing the upgrade - * * @throws IllegalStateException if the package is not currently installed */ - Pair, Set> upgradePackage( - FakeDeviceState.PackageBuilder pkg, int userId) throws OperationFailedException { + void upgradeAndAssert(FakeDeviceState.PackageBuilder pkg, int userId, + @NonNull Set onReplacingUpdatedPackages, + @NonNull Set 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 updatedPackages1 = - CollectionUtils.emptyIfNull(mImpl.onPackageReplacing(pkg.packageName, userId)); - + assertEquals(onReplacingUpdatedPackages, mImpl.onPackageReplacing(pkg.packageName, userId)); mState.add(pkg, userId); - final Set 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 uninstallPackage(String packageName, int userId) { + void uninstallAndAssert(@NonNull String packageName, int userId, + @NonNull Set onRemovedUpdatedPackages) { final FakeDeviceState.Package pkg = mState.select(packageName, userId); if (pkg == null) { - throw new IllegalStateException("package " + packageName+ " not installed"); + 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. */