Fix PackageManagerSettingsTests and add KeySet info.

Add unit tests for the keyset portion of packages.xml.  Also fix previously
broken test by adding UserManagerService reference.

Bug: 19530911
Bug: 19530120
Change-Id: I251fc3e9dc983f1d63f9e84905d3ed0e64843def

3 files changed, 327 insertions, 149 deletions

diff --git a/services/tests/servicestests/src/com/android/server/pm/KeySetManagerServiceTest.java b/services/tests/servicestests/src/com/android/server/pm/KeySetManagerServiceTest.java
index fbdb20b..2557974 100644
--- a/services/tests/servicestests/src/com/android/server/pm/KeySetManagerServiceTest.java
+++ b/services/tests/servicestests/src/com/android/server/pm/KeySetManagerServiceTest.java
@@ -24,7 +24,6 @@ import android.util.ArraySet;
 import android.util.LongSparseArray;
 import com.android.internal.util.ArrayUtils;
 
-import java.lang.reflect.Field;
 import java.io.File;
 import java.io.IOException;
 import java.security.cert.CertificateException;
@@ -43,53 +42,6 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
                 "", 1, 0, 0);
     }
 
-    public PublicKey getPubKey(long pkId) throws NoSuchFieldException, IllegalAccessException {
-        Field pkField = mKsms.getClass().getDeclaredField("mPublicKeys");
-        pkField.setAccessible(true);
-        LongSparseArray<KeySetManagerService.PublicKeyHandle> mPublicKeys =
-            (LongSparseArray<KeySetManagerService.PublicKeyHandle>) pkField.get(mKsms);
-        KeySetManagerService.PublicKeyHandle pkh = mPublicKeys.get(pkId);
-        if (pkh == null) {
-            return null;
-        } else {
-            return pkh.getKey();
-        }
-    }
-
-    public int getPubKeyRefCount(long pkId) throws NoSuchFieldException, IllegalAccessException {
-        Field pkField = mKsms.getClass().getDeclaredField("mPublicKeys");
-        pkField.setAccessible(true);
-        LongSparseArray<KeySetManagerService.PublicKeyHandle> mPublicKeys =
-            (LongSparseArray<KeySetManagerService.PublicKeyHandle>) pkField.get(mKsms);
-        KeySetManagerService.PublicKeyHandle pkh = mPublicKeys.get(pkId);
-        if (pkh == null) {
-            return 0;
-        } else {
-            return pkh.getRefCountLPr();
-        }
-    }
-
-    public int getKeySetRefCount(long keysetId) throws NoSuchFieldException, IllegalAccessException {
-        Field ksField = mKsms.getClass().getDeclaredField("mKeySets");
-        ksField.setAccessible(true);
-        LongSparseArray<KeySetHandle> mKeySets =
-            (LongSparseArray<KeySetHandle>) ksField.get(mKsms);
-        KeySetHandle ksh = mKeySets.get(keysetId);
-        if (ksh == null) {
-            return 0;
-        } else {
-            return ksh.getRefCountLPr();
-        }
-    }
-
-    public LongSparseArray<ArraySet<Long>> getKeySetMapping()
-            throws NoSuchFieldException, IllegalAccessException {
-        Field ksField = mKsms.getClass().getDeclaredField("mKeySetMapping");
-        ksField.setAccessible(true);
-        return (LongSparseArray<ArraySet<Long>>) ksField.get(mKsms);
-    }
-
-
     @Override
     public void setUp() throws Exception {
         super.setUp();
@@ -168,10 +120,10 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         signingKeys.add(keyA);
         mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys);
 
-        assertEquals(1, getKeySetRefCount(1));
-        assertEquals(1, getPubKeyRefCount(1));
-        assertEquals(keyA, getPubKey(1));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(keyA, KeySetUtils.getPubKey(mKsms, 1));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(1, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(1);
         assertEquals(1, mapping.size());
@@ -198,10 +150,10 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         /* add again, to represent upgrade of package */
         mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys);
 
-        assertEquals(1, getKeySetRefCount(1));
-        assertEquals(1, getPubKeyRefCount(1));
-        assertEquals(keyA, getPubKey(1));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(keyA, KeySetUtils.getPubKey(mKsms, 1));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(1, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(1);
         assertEquals(1, mapping.size());
@@ -231,12 +183,12 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         signingKeys.add(keyB);
         mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys);
 
-        assertEquals(0, getKeySetRefCount(1));
-        assertEquals(1, getKeySetRefCount(2));
-        assertEquals(0, getPubKeyRefCount(1));
-        assertEquals(1, getPubKeyRefCount(2));
-        assertEquals(keyB, getPubKey(2));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
+        assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 2));
+        assertEquals(keyB, KeySetUtils.getPubKey(mKsms, 2));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(1, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(2);
         assertEquals(1, mapping.size());
@@ -269,13 +221,13 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         signingKeys.add(keyB);
         mKsms.addSigningKeySetToPackageLPw(ps1.name, signingKeys);
 
-        assertEquals(1, getKeySetRefCount(1));
-        assertEquals(1, getKeySetRefCount(2));
-        assertEquals(1, getPubKeyRefCount(1));
-        assertEquals(1, getPubKeyRefCount(2));
-        assertEquals(keyA, getPubKey(1));
-        assertEquals(keyB, getPubKey(2));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 2));
+        assertEquals(keyA, KeySetUtils.getPubKey(mKsms, 1));
+        assertEquals(keyB, KeySetUtils.getPubKey(mKsms, 2));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(2, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(1);
         assertEquals(1, mapping.size());
@@ -312,10 +264,10 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         mKsms.addSigningKeySetToPackageLPw(ps2.name, signingKeys2);
 
         /* verify first is unchanged */
-        assertEquals(1, getKeySetRefCount(1));
-        assertEquals(1, getPubKeyRefCount(1));
-        assertEquals(keyA, getPubKey(1));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(keyA, KeySetUtils.getPubKey(mKsms, 1));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(2, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(1);
         assertEquals(1, mapping.size());
@@ -323,9 +275,9 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         assertEquals(1, ps1.keySetData.getProperSigningKeySet());
 
         /* verify second */
-        assertEquals(1, getKeySetRefCount(2));
-        assertEquals(1, getPubKeyRefCount(2));
-        assertEquals(keyB, getPubKey(2));
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 2));
+        assertEquals(keyB, KeySetUtils.getPubKey(mKsms, 2));
         mapping = ksMapping.get(2);
         assertEquals(1, mapping.size());
         assertTrue(mapping.contains(new  Long(2)));
@@ -353,10 +305,10 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         /* add again for second package */
         mKsms.addSigningKeySetToPackageLPw(ps2.name, signingKeys);
 
-        assertEquals(2, getKeySetRefCount(1));
-        assertEquals(1, getPubKeyRefCount(1));
-        assertEquals(keyA, getPubKey(1));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(2, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(keyA, KeySetUtils.getPubKey(mKsms, 1));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(1, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(1);
         assertEquals(1, mapping.size());
@@ -388,13 +340,13 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         signingKeys.add(keyB);
         mKsms.addSigningKeySetToPackageLPw(ps2.name, signingKeys);
 
-        assertEquals(1, getKeySetRefCount(1));
-        assertEquals(1, getKeySetRefCount(2));
-        assertEquals(2, getPubKeyRefCount(1));
-        assertEquals(1, getPubKeyRefCount(2));
-        assertEquals(keyA, getPubKey(1));
-        assertEquals(keyB, getPubKey(2));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
+        assertEquals(2, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 2));
+        assertEquals(keyA, KeySetUtils.getPubKey(mKsms, 1));
+        assertEquals(keyB, KeySetUtils.getPubKey(mKsms, 2));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(2, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(1);
         assertEquals(1, mapping.size());
@@ -429,16 +381,17 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         signingKeys.add(keyB);
         mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys);
 
-        assertEquals(0, getKeySetRefCount(1));
-        assertEquals(1, getKeySetRefCount(2));
-        assertEquals(0, getPubKeyRefCount(1));
-        assertEquals(1, getPubKeyRefCount(2));
-        assertEquals(1, getPubKeyRefCount(3));
+        assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
+        assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 2));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 3));
 
         /* the pub key is removed w/prev keyset and may be either 2 or 3 */
-        assertTrue(keyA.equals(getPubKey(2)) && keyB.equals(getPubKey(3))
-                   || keyA.equals(getPubKey(3)) && keyB.equals(getPubKey(2)));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertTrue(keyA.equals(KeySetUtils.getPubKey(mKsms, 2)) || keyA.equals(KeySetUtils.getPubKey(mKsms, 3)));
+        assertTrue(keyB.equals(KeySetUtils.getPubKey(mKsms, 2)) || keyB.equals(KeySetUtils.getPubKey(mKsms, 3)));
+        assertFalse(KeySetUtils.getPubKey(mKsms, 2).equals(KeySetUtils.getPubKey(mKsms, 3)));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(1, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(2);
         assertEquals(2, mapping.size());
@@ -462,10 +415,10 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         definedKS.put("aliasA", keys);
         mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS);
 
-        assertEquals(1, getKeySetRefCount(1));
-        assertEquals(1, getPubKeyRefCount(1));
-        assertEquals(keyA, getPubKey(1));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(keyA, KeySetUtils.getPubKey(mKsms, 1));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(1, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(1);
         assertEquals(1, mapping.size());
@@ -490,10 +443,10 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         definedKS.put("aliasA2", keys);
         mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS);
 
-        assertEquals(2, getKeySetRefCount(1));
-        assertEquals(1, getPubKeyRefCount(1));
-        assertEquals(keyA, getPubKey(1));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(2, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(keyA, KeySetUtils.getPubKey(mKsms, 1));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(1, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(1);
         assertEquals(1, mapping.size());
@@ -527,12 +480,12 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         definedKS.put("aliasB", keys);
         mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS);
 
-        assertEquals(0, getKeySetRefCount(1));
-        assertEquals(0, getPubKeyRefCount(1));
-        assertEquals(1, getKeySetRefCount(2));
-        assertEquals(1, getPubKeyRefCount(2));
-        assertEquals(keyB, getPubKey(2));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 2));
+        assertEquals(keyB, KeySetUtils.getPubKey(mKsms, 2));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(1, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(2);
         assertEquals(1, mapping.size());
@@ -566,12 +519,12 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         definedKS.put("aliasA", keys);
         mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS);
 
-        assertEquals(0, getKeySetRefCount(1));
-        assertEquals(0, getPubKeyRefCount(1));
-        assertEquals(1, getKeySetRefCount(2));
-        assertEquals(1, getPubKeyRefCount(2));
-        assertEquals(keyB, getPubKey(2));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 2));
+        assertEquals(keyB, KeySetUtils.getPubKey(mKsms, 2));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(1, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(2);
         assertEquals(1, mapping.size());
@@ -608,10 +561,10 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         definedKS.put("aliasC", keys1);
         mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS);
 
-        assertEquals(1, getKeySetRefCount(3));
-        assertEquals(1, getPubKeyRefCount(3));
-        assertEquals(keyC, getPubKey(3));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 3));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 3));
+        assertEquals(keyC, KeySetUtils.getPubKey(mKsms, 3));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(2, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(3);
         assertEquals(1, mapping.size());
@@ -619,13 +572,13 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         assertEquals(new Long(3), ps.keySetData.getAliases().get("aliasC"));
 
         /* either keyset w/keyA or w/keyB was added first, address both cases */
-        if (1 == getKeySetRefCount(1)) {
+        if (1 == KeySetUtils.getKeySetRefCount(mKsms, 1)) {
 
             /* keyB was added first and should have keyset 1 and pub-key 1 */
-            assertEquals(1, getPubKeyRefCount(1));
-            assertEquals(0, getKeySetRefCount(2));
-            assertEquals(0, getPubKeyRefCount(2));
-            assertEquals(keyB, getPubKey(1));
+            assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+            assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 2));
+            assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 2));
+            assertEquals(keyB, KeySetUtils.getPubKey(mKsms, 1));
             mapping = ksMapping.get(1);
             assertEquals(1, mapping.size());
             assertTrue(mapping.contains(new Long(1)));
@@ -633,11 +586,11 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         } else {
 
             /* keyA was added first and keyB has id 2 */
-            assertEquals(1, getKeySetRefCount(2));
-            assertEquals(1, getPubKeyRefCount(2));
-            assertEquals(0, getKeySetRefCount(1));
-            assertEquals(0, getPubKeyRefCount(1));
-            assertEquals(keyB, getPubKey(2));
+            assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
+            assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 2));
+            assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
+            assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+            assertEquals(keyB, KeySetUtils.getPubKey(mKsms, 2));
             mapping = ksMapping.get(2);
             assertEquals(1, mapping.size());
             assertTrue(mapping.contains(new Long(2)));
@@ -674,14 +627,14 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         definedKS.put("aliasA", keys1);
         mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS);
 
-        assertEquals(0, getKeySetRefCount(1));
-        assertEquals(0, getKeySetRefCount(2));
-        assertEquals(1, getKeySetRefCount(3));
-        assertEquals(0, getPubKeyRefCount(1));
-        assertEquals(0, getPubKeyRefCount(2));
-        assertEquals(1, getPubKeyRefCount(3));
-        assertEquals(keyA, getPubKey(3));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 2));
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 3));
+        assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 2));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 3));
+        assertEquals(keyA, KeySetUtils.getPubKey(mKsms, 3));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(1, ksMapping.size());
         ArraySet<Long> mapping = ksMapping.get(3);
         assertEquals(1, mapping.size());
@@ -780,9 +733,9 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
 
         /* remove its references */
         mKsms.removeAppKeySetDataLPw(ps.name);
-        assertEquals(0, getKeySetRefCount(1));
-        assertEquals(0, getPubKeyRefCount(1));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(0, ksMapping.size());
         assertEquals(PackageKeySetData.KEYSET_UNASSIGNED, ps.keySetData.getProperSigningKeySet());
     }
@@ -807,9 +760,9 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         /* remove references from first package */
         mKsms.removeAppKeySetDataLPw(ps1.name);
 
-        assertEquals(1, getKeySetRefCount(1));
-        assertEquals(1, getPubKeyRefCount(1));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(1, ksMapping.size());
         assertEquals(PackageKeySetData.KEYSET_UNASSIGNED, ps1.keySetData.getProperSigningKeySet());
         assertEquals(1, ps2.keySetData.getProperSigningKeySet());
@@ -840,9 +793,9 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
         mKsms.addUpgradeKeySetsToPackageLPw(ps.name, upgradeKS);
         mKsms.removeAppKeySetDataLPw(ps.name);
 
-        assertEquals(0, getKeySetRefCount(1));
-        assertEquals(0, getPubKeyRefCount(1));
-        LongSparseArray<ArraySet<Long>> ksMapping = getKeySetMapping();
+        assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
+        assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
         assertEquals(0, ksMapping.size());
         assertEquals(PackageKeySetData.KEYSET_UNASSIGNED, ps.keySetData.getProperSigningKeySet());
         assertEquals(0, ps.keySetData.getAliases().size());
diff --git a/services/tests/servicestests/src/com/android/server/pm/KeySetUtils.java b/services/tests/servicestests/src/com/android/server/pm/KeySetUtils.java
new file mode 100644
index 0000000..9e1a366
--- /dev/null
+++ b/services/tests/servicestests/src/com/android/server/pm/KeySetUtils.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.pm;
+
+import android.util.ArraySet;
+import android.util.LongSparseArray;
+
+import java.lang.reflect.Field;
+import java.security.PublicKey;
+
+public class KeySetUtils {
+
+    public static PublicKey getPubKey(KeySetManagerService ksms, long pkId)
+            throws NoSuchFieldException, IllegalAccessException {
+        Field pkField = ksms.getClass().getDeclaredField("mPublicKeys");
+        pkField.setAccessible(true);
+        LongSparseArray<KeySetManagerService.PublicKeyHandle> mPublicKeys =
+            (LongSparseArray<KeySetManagerService.PublicKeyHandle>) pkField.get(ksms);
+        KeySetManagerService.PublicKeyHandle pkh = mPublicKeys.get(pkId);
+        if (pkh == null) {
+            return null;
+        } else {
+            return pkh.getKey();
+        }
+    }
+
+    public static int getPubKeyRefCount(KeySetManagerService ksms, long pkId)
+            throws NoSuchFieldException, IllegalAccessException {
+        Field pkField = ksms.getClass().getDeclaredField("mPublicKeys");
+        pkField.setAccessible(true);
+        LongSparseArray<KeySetManagerService.PublicKeyHandle> mPublicKeys =
+            (LongSparseArray<KeySetManagerService.PublicKeyHandle>) pkField.get(ksms);
+        KeySetManagerService.PublicKeyHandle pkh = mPublicKeys.get(pkId);
+        if (pkh == null) {
+            return 0;
+        } else {
+            return pkh.getRefCountLPr();
+        }
+    }
+
+    public static int getKeySetRefCount(KeySetManagerService ksms, long keysetId)
+            throws NoSuchFieldException, IllegalAccessException {
+        Field ksField = ksms.getClass().getDeclaredField("mKeySets");
+        ksField.setAccessible(true);
+        LongSparseArray<KeySetHandle> mKeySets =
+            (LongSparseArray<KeySetHandle>) ksField.get(ksms);
+        KeySetHandle ksh = mKeySets.get(keysetId);
+        if (ksh == null) {
+            return 0;
+        } else {
+            return ksh.getRefCountLPr();
+        }
+    }
+
+    public static LongSparseArray<ArraySet<Long>> getKeySetMapping(KeySetManagerService ksms)
+            throws NoSuchFieldException, IllegalAccessException {
+        Field ksField = ksms.getClass().getDeclaredField("mKeySetMapping");
+        ksField.setAccessible(true);
+        return (LongSparseArray<ArraySet<Long>>) ksField.get(ksms);
+    }
+
+    public static Long getLastIssuedKeyId(KeySetManagerService ksms)
+            throws NoSuchFieldException, IllegalAccessException {
+        Field ksField = ksms.getClass().getDeclaredField("lastIssuedKeyId");
+        ksField.setAccessible(true);
+        return (Long) ksField.get(ksms);
+    }
+
+    public static Long getLastIssuedKeySetId(KeySetManagerService ksms)
+            throws NoSuchFieldException, IllegalAccessException {
+        Field ksField = ksms.getClass().getDeclaredField("lastIssuedKeySetId");
+        ksField.setAccessible(true);
+        return (Long) ksField.get(ksms);
+    }
+}
diff --git a/services/tests/servicestests/src/com/android/server/pm/PackageManagerSettingsTests.java b/services/tests/servicestests/src/com/android/server/pm/PackageManagerSettingsTests.java
index a3f3a5d..ed1db6f 100644
--- a/services/tests/servicestests/src/com/android/server/pm/PackageManagerSettingsTests.java
+++ b/services/tests/servicestests/src/com/android/server/pm/PackageManagerSettingsTests.java
@@ -21,15 +21,21 @@ import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED
 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER;
 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
 
+import android.content.Context;
+import android.content.pm.PackageParser;
 import android.test.AndroidTestCase;
+import android.util.ArrayMap;
 import android.util.ArraySet;
 import android.util.Log;
+import android.util.LongSparseArray;
 
 import com.android.internal.os.AtomicFile;
 
+import java.lang.reflect.Constructor;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.security.PublicKey;
 
 public class PackageManagerSettingsTests extends AndroidTestCase {
     private static final String PACKAGE_NAME_2 = "com.google.app2";
@@ -67,18 +73,24 @@ public class PackageManagerSettingsTests extends AndroidTestCase {
                 + "</permissions>"
                 + "<package name=\"com.google.app1\" codePath=\"/system/app/app1.apk\" nativeLibraryPath=\"/data/data/com.google.app1/lib\" flags=\"1\" ft=\"1360e2caa70\" it=\"135f2f80d08\" ut=\"1360e2caa70\" version=\"1109\" sharedUserId=\"11000\">"
                 + "<sigs count=\"1\">"
-                + "<cert index=\"0\" key=\"308886\" />"
+                + "<cert index=\"0\" key=\"" + KeySetStrings.ctsKeySetCertA + "\" />"
                 + "</sigs>"
+                + "<proper-signing-keyset identifier=\"1\" />"
                 + "</package>"
                 + "<package name=\"com.google.app2\" codePath=\"/system/app/app2.apk\" nativeLibraryPath=\"/data/data/com.google.app2/lib\" flags=\"1\" ft=\"1360e578718\" it=\"135f2f80d08\" ut=\"1360e578718\" version=\"15\" enabled=\"3\" userId=\"11001\">"
                 + "<sigs count=\"1\">"
                 + "<cert index=\"0\" />"
                 + "</sigs>"
+                + "<proper-signing-keyset identifier=\"1\" />"
+                + "<defined-keyset alias=\"AB\" identifier=\"4\" />"
                 + "</package>"
                 + "<package name=\"com.android.app3\" codePath=\"/system/app/app3.apk\" nativeLibraryPath=\"/data/data/com.android.app3/lib\" flags=\"1\" ft=\"1360e577b60\" it=\"135f2f80d08\" ut=\"1360e577b60\" version=\"15\" userId=\"11030\">"
                 + "<sigs count=\"1\">"
-                + "<cert index=\"1\" key=\"308366\" />"
+                + "<cert index=\"1\" key=\"" + KeySetStrings.ctsKeySetCertB + "\" />"
                 + "</sigs>"
+                + "<proper-signing-keyset identifier=\"2\" />"
+                + "<upgrade-keyset identifier=\"3\" />"
+                + "<defined-keyset alias=\"C\" identifier=\"3\" />"
                 + "</package>"
                 + "<shared-user name=\"com.android.shared1\" userId=\"11000\">"
                 + "<sigs count=\"1\">"
@@ -88,6 +100,30 @@ public class PackageManagerSettingsTests extends AndroidTestCase {
                 + "<item name=\"android.permission.REBOOT\" />"
                 + "</perms>"
                 + "</shared-user>"
+                + "<keyset-settings version=\"1\">"
+                + "<keys>"
+                + "<public-key identifier=\"1\" value=\"" + KeySetStrings.ctsKeySetPublicKeyA + "\" />"
+                + "<public-key identifier=\"2\" value=\"" + KeySetStrings.ctsKeySetPublicKeyB + "\" />"
+                + "<public-key identifier=\"3\" value=\"" + KeySetStrings.ctsKeySetPublicKeyC + "\" />"
+                + "</keys>"
+                + "<keysets>"
+                + "<keyset identifier=\"1\">"
+                + "<key-id identifier=\"1\" />"
+                + "</keyset>"
+                + "<keyset identifier=\"2\">"
+                + "<key-id identifier=\"2\" />"
+                + "</keyset>"
+                + "<keyset identifier=\"3\">"
+                + "<key-id identifier=\"3\" />"
+                + "</keyset>"
+                + "<keyset identifier=\"4\">"
+                + "<key-id identifier=\"1\" />"
+                + "<key-id identifier=\"2\" />"
+                + "</keyset>"
+                + "</keysets>"
+                + "<lastIssuedKeyId value=\"3\" />"
+                + "<lastIssuedKeySetId value=\"4\" />"
+                + "</keyset-settings>"
                 + "</packages>").getBytes());
     }
 
@@ -131,6 +167,104 @@ public class PackageManagerSettingsTests extends AndroidTestCase {
         writePackagesList();
     }
 
+    private void createUserManagerServiceRef() throws ReflectiveOperationException {
+        Constructor<UserManagerService> umsc =
+                UserManagerService.class.getDeclaredConstructor(
+                        Context.class,
+                        PackageManagerService.class,
+                        Object.class,
+                        Object.class,
+                        File.class,
+                        File.class);
+        umsc.setAccessible(true);
+        UserManagerService ums = umsc.newInstance(getContext(), null,
+                new Object(), new Object(), getContext().getFilesDir(),
+                new File(getContext().getFilesDir(), "user"));
+    }
+
+    private void verifyKeySetMetaData(Settings settings)
+            throws ReflectiveOperationException, IllegalAccessException {
+        ArrayMap<String, PackageSetting> packages = settings.mPackages;
+        KeySetManagerService ksms = settings.mKeySetManagerService;
+
+        /* verify keyset and public key ref counts */
+        assertEquals(2, KeySetUtils.getKeySetRefCount(ksms, 1));
+        assertEquals(1, KeySetUtils.getKeySetRefCount(ksms, 2));
+        assertEquals(1, KeySetUtils.getKeySetRefCount(ksms, 3));
+        assertEquals(1, KeySetUtils.getKeySetRefCount(ksms, 4));
+        assertEquals(2, KeySetUtils.getPubKeyRefCount(ksms, 1));
+        assertEquals(2, KeySetUtils.getPubKeyRefCount(ksms, 2));
+        assertEquals(1, KeySetUtils.getPubKeyRefCount(ksms, 3));
+
+        /* verify public keys properly read */
+        PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
+        PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB);
+        PublicKey keyC = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyC);
+        assertEquals(keyA, KeySetUtils.getPubKey(ksms, 1));
+        assertEquals(keyB, KeySetUtils.getPubKey(ksms, 2));
+        assertEquals(keyC, KeySetUtils.getPubKey(ksms, 3));
+
+        /* verify mapping is correct (ks -> pub keys) */
+        LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(ksms);
+        ArraySet<Long> mapping = ksMapping.get(1);
+        assertEquals(1, mapping.size());
+        assertTrue(mapping.contains(new Long(1)));
+        mapping = ksMapping.get(2);
+        assertEquals(1, mapping.size());
+        assertTrue(mapping.contains(new Long(2)));
+        mapping = ksMapping.get(3);
+        assertEquals(1, mapping.size());
+        assertTrue(mapping.contains(new Long(3)));
+        mapping = ksMapping.get(4);
+        assertEquals(2, mapping.size());
+        assertTrue(mapping.contains(new Long(1)));
+        assertTrue(mapping.contains(new Long(2)));
+
+        /* verify lastIssuedIds are consistent */
+        assertEquals(new Long(3), KeySetUtils.getLastIssuedKeyId(ksms));
+        assertEquals(new Long(4), KeySetUtils.getLastIssuedKeySetId(ksms));
+
+        /* verify packages have been given the appropriat information */
+        PackageSetting ps = packages.get("com.google.app1");
+        assertEquals(1, ps.keySetData.getProperSigningKeySet());
+        ps = packages.get("com.google.app2");
+        assertEquals(1, ps.keySetData.getProperSigningKeySet());
+        assertEquals(new Long(4), ps.keySetData.getAliases().get("AB"));
+        ps = packages.get("com.android.app3");
+        assertEquals(2, ps.keySetData.getProperSigningKeySet());
+        assertEquals(new Long(3), ps.keySetData.getAliases().get("C"));
+        assertEquals(1, ps.keySetData.getUpgradeKeySets().length);
+        assertEquals(3, ps.keySetData.getUpgradeKeySets()[0]);
+    }
+
+    /* make sure our initialized keysetmanagerservice metadata matches packages.xml */
+    public void testReadKeySetSettings()
+            throws ReflectiveOperationException, IllegalAccessException {
+
+        /* write out files and read */
+        writeOldFiles();
+        createUserManagerServiceRef();
+        Settings settings = new Settings(getContext().getFilesDir(), new Object());
+        assertEquals(true, settings.readLPw(null, null, 0, false));
+        verifyKeySetMetaData(settings);
+    }
+
+    /* read in data, write it out, and read it back in.  Verify same. */
+    public void testWriteKeySetSettings()
+            throws ReflectiveOperationException, IllegalAccessException {
+
+        /* write out files and read */
+        writeOldFiles();
+        createUserManagerServiceRef();
+        Settings settings = new Settings(getContext().getFilesDir(), new Object());
+        assertEquals(true, settings.readLPw(null, null, 0, false));
+
+        /* write out, read back in and verify the same */
+        settings.writeLPr();
+        assertEquals(true, settings.readLPw(null, null, 0, false));
+        verifyKeySetMetaData(settings);
+    }
+
     public void testSettingsReadOld() {
         // Write the package files and make sure they're parsed properly the first time
         writeOldFiles();
@@ -149,9 +283,11 @@ public class PackageManagerSettingsTests extends AndroidTestCase {
         assertEquals(COMPONENT_ENABLED_STATE_DEFAULT, ps.getEnabled(1));
     }
 
-    public void testNewPackageRestrictionsFile() {
+    public void testNewPackageRestrictionsFile() throws ReflectiveOperationException {
+
         // Write the package files and make sure they're parsed properly the first time
         writeOldFiles();
+        createUserManagerServiceRef();
         Settings settings = new Settings(getContext().getFilesDir(), new Object());
         assertEquals(true, settings.readLPw(null, null, 0, false));
         settings.writeLPr();