Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

OMS: Assert which packages are updated

Browse Source 
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
This commit is contained in:
Ryan Mitchell
2021-02-17 11:30:36 -08:00
parent d145f376ca
commit 60f912286d
3 changed files with 190 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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),
new PackageAndUser(otherTarget, USER),
new PackageAndUser(OVERLAY, USER))));
final Set<PackageAndUser> allPackages =
Set.of(new PackageAndUser(TARGET, USER),
new PackageAndUser(otherTarget, 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 */);
impl.updateOverlaysForUser(USER);
final Set<PackageAndUser> 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<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);

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

@@ -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<OverlayInfo> 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<String, List<OverlayInfo>> 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<PackageAndUser>, Set<PackageAndUser>> 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);
}
}

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

@@ -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");
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. */