Snap for 10341497 from c32236293fab2b7a2b2a74de6bbc05ef89c96821 to udc-d2-releaseandroid-14.0.0_r45android-14.0.0_r44android-14.0.0_r43android-14.0.0_r42android-14.0.0_r41android-14.0.0_r40android-14.0.0_r39android-14.0.0_r38android14-d2-s5-releaseandroid14-d2-s4-releaseandroid14-d2-s3-releaseandroid14-d2-s2-releaseandroid14-d2-s1-releaseandroid14-d2-release

Change-Id: I671568bcbbd9a94f462d25404614a6e6be9d2f64

12 files changed, 717 insertions, 712 deletions

diff --git a/tests/chronicletests/Android.bp b/tests/chronicletests/Android.bp
index 3ebd6cf6..184e987f 100644
--- a/tests/chronicletests/Android.bp
+++ b/tests/chronicletests/Android.bp
@@ -39,11 +39,14 @@ android_test {
         "kotlinx-coroutines-android",
         "ondevicepersonalization-protos",
     ],
+    sdk_version: "module_current",
     target_sdk_version: "current",
     min_sdk_version: "Tiramisu",
-    test_mainline_modules: ["com.google.android.ondevicepersonalization.apex"],
+    certificate: "platform",
     test_suites: [
         "general-tests",
         "mts-ondevicepersonalization",
     ],
+    manifest: "AndroidManifest.xml",
+    test_config: "AndroidTest.xml",
 }
diff --git a/tests/chronicletests/AndroidManifest.xml b/tests/chronicletests/AndroidManifest.xml
index f23fa6fa..abf51afc 100644
--- a/tests/chronicletests/AndroidManifest.xml
+++ b/tests/chronicletests/AndroidManifest.xml
@@ -18,7 +18,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
           package="com.android.libraries.pcc.chronicle.test" >
 
-    <application android:label="OdpChronicleTests">
+    <application android:label="OdpChronicleTests"
+                 android:debuggable="true">
         <uses-library android:name="android.test.runner"/>
     </application>
     <instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
diff --git a/tests/chronicletests/AndroidTest.xml b/tests/chronicletests/AndroidTest.xml
index 2b15e2e8..0dd519f1 100644
--- a/tests/chronicletests/AndroidTest.xml
+++ b/tests/chronicletests/AndroidTest.xml
@@ -27,7 +27,7 @@
     </target_preparer>
 
     <test class="com.android.tradefed.testtype.AndroidJUnitTest">
-        <option name="hidden-api-checks" value="false" />
+        <option name="hidden-api-checks" value="false" /><!-- Allow hidden API uses -->
         <option name="package" value="com.android.libraries.pcc.chronicle.test"/>
     </test>
 
@@ -36,4 +36,5 @@
         <option name="mainline-module-package-name"
                 value="com.google.android.ondevicepersonalization" />
     </object>
+    <option name="config-descriptor:metadata" key="mainline-param" value="com.google.android.ondevicepersonalization.apex" />
 </configuration>
diff --git a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyAnnotationTest.kt b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyAnnotationTest.kt
index 25a09f29..97482b6a 100644
--- a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyAnnotationTest.kt
+++ b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyAnnotationTest.kt
@@ -14,39 +14,39 @@
  * limitations under the License.
  */
 
-// package com.android.libraries.pcc.chronicle.test
+package com.android.libraries.pcc.chronicle.test
 
-// import com.google.common.truth.Truth.assertThat
-// import org.junit.Test
-// import androidx.test.ext.junit.runners.AndroidJUnit4
-// import org.junit.runner.RunWith
-// import com.android.libraries.pcc.chronicle.api.policy.annotation.annotation
-// import com.android.libraries.pcc.chronicle.api.policy.annotation.AnnotationParam
-// import com.android.libraries.pcc.chronicle.api.policy.annotation.AnnotationBuilder
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.runner.RunWith
+import com.android.libraries.pcc.chronicle.api.policy.annotation.annotation
+import com.android.libraries.pcc.chronicle.api.policy.annotation.AnnotationParam
+import com.android.libraries.pcc.chronicle.api.policy.annotation.AnnotationBuilder
 
 
-// @RunWith(AndroidJUnit4::class)
-// class ChronicleApiPolicyAnnotationTest {
-//     @Test
-//     fun testAnnotationEmptyBlock() {
-//         val actual = annotation("ttl")
+@RunWith(AndroidJUnit4::class)
+class ChronicleApiPolicyAnnotationTest {
+    @Test
+    fun testAnnotationEmptyBlock() {
+        val actual = annotation("ttl")
 
-//         assertThat(actual.name).isEqualTo("ttl")
-//         assertThat(actual.params).isEmpty()
-//     }
+        assertThat(actual.name).isEqualTo("ttl")
+        assertThat(actual.params).isEmpty()
+    }
 
-//     @Test
-//     fun testAnnotationNonEmptyBlock() {
-//         val actual = annotation("ttl") {
-//             param("stringParam", "My String Value")
-//             param("intParam", 42)
-//             param("boolParam", true)
-//         }
+    @Test
+    fun testAnnotationNonEmptyBlock() {
+        val actual = annotation("ttl") {
+            param("stringParam", "My String Value")
+            param("intParam", 42)
+            param("boolParam", true)
+        }
 
-//         assertThat(actual.name).isEqualTo("ttl")
-//         assertThat(actual.params).hasSize(3)
-//         assertThat(actual.getParam("intParam")).isEqualTo(AnnotationParam.Num(42))
-//         assertThat(actual.getStringParam("stringParam")).isEqualTo("My String Value")
-//         assertThat(actual.getOptionalStringParam("Param not Found!")).isEqualTo(null)
-//     }
-// }
\ No newline at end of file
+        assertThat(actual.name).isEqualTo("ttl")
+        assertThat(actual.params).hasSize(3)
+        assertThat(actual.getParam("intParam")).isEqualTo(AnnotationParam.Num(42))
+        assertThat(actual.getStringParam("stringParam")).isEqualTo("My String Value")
+        assertThat(actual.getOptionalStringParam("Param not Found!")).isEqualTo(null)
+    }
+}
\ No newline at end of file
diff --git a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyBuilderTest.kt b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyBuilderTest.kt
index 3c04fea1..39f53453 100644
--- a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyBuilderTest.kt
+++ b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyBuilderTest.kt
@@ -14,82 +14,82 @@
  * limitations under the License.
  */
 
-// package com.android.libraries.pcc.chronicle.test
+package com.android.libraries.pcc.chronicle.test
 
-// import androidx.test.core.app.ApplicationProvider
-// import androidx.test.ext.junit.runners.AndroidJUnit4
-// import androidx.test.ext.truth.os.ParcelableSubject.assertThat
-// import org.junit.Test
-// import org.junit.Before
-// import org.junit.BeforeClass
-// import org.junit.runner.RunWith
-// import com.android.libraries.pcc.chronicle.api.policy.Policy
-// import com.android.libraries.pcc.chronicle.test.data.Foobar
-// import com.android.libraries.pcc.chronicle.test.data.SimpleData
-// import com.android.libraries.pcc.chronicle.api.policy.builder.policy
-// import com.android.libraries.pcc.chronicle.api.policy.builder.target
-// import com.android.libraries.pcc.chronicle.api.policy.StorageMedium
-// import com.android.libraries.pcc.chronicle.api.policy.PolicyTarget
-// import com.android.libraries.pcc.chronicle.api.policy.PolicyField
-// import com.android.libraries.pcc.chronicle.api.policy.PolicyRetention
-// import com.android.libraries.pcc.chronicle.api.FieldType
-// import com.android.libraries.pcc.chronicle.api.policy.UsageType
-// import com.android.libraries.pcc.chronicle.api.policy.builder.PolicyConfigBuilder
-// import com.android.libraries.pcc.chronicle.api.dataTypeDescriptor
-// import com.google.common.truth.Truth.assertThat
-// import java.time.Duration
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.ext.truth.os.ParcelableSubject.assertThat
+import org.junit.Test
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.runner.RunWith
+import com.android.libraries.pcc.chronicle.api.policy.Policy
+import com.android.libraries.pcc.chronicle.test.data.Foobar
+import com.android.libraries.pcc.chronicle.test.data.SimpleData
+import com.android.libraries.pcc.chronicle.api.policy.builder.policy
+import com.android.libraries.pcc.chronicle.api.policy.builder.target
+import com.android.libraries.pcc.chronicle.api.policy.StorageMedium
+import com.android.libraries.pcc.chronicle.api.policy.PolicyTarget
+import com.android.libraries.pcc.chronicle.api.policy.PolicyField
+import com.android.libraries.pcc.chronicle.api.policy.PolicyRetention
+import com.android.libraries.pcc.chronicle.api.FieldType
+import com.android.libraries.pcc.chronicle.api.policy.UsageType
+import com.android.libraries.pcc.chronicle.api.policy.builder.PolicyConfigBuilder
+import com.android.libraries.pcc.chronicle.api.dataTypeDescriptor
+import com.google.common.truth.Truth.assertThat
+import java.time.Duration
 
-// /**
-//  * Test of building Chronicle [Policy] using [PolicyBuilder].
-//  */
-// @RunWith(AndroidJUnit4::class)
-// class ChronicleApiPolicyBuilderTest {
+/**
+ * Test of building Chronicle [Policy] using [PolicyBuilder].
+ */
+@RunWith(AndroidJUnit4::class)
+class ChronicleApiPolicyBuilderTest {
 
-//     val FOOBAR_DTD = dataTypeDescriptor("Foobar", Foobar::class) {
-//         "name" to FieldType.String
-//     }
+    val FOOBAR_DTD = dataTypeDescriptor("Foobar", Foobar::class) {
+        "name" to FieldType.String
+    }
 
-//     val SIMPLE_DATA_DTD = dataTypeDescriptor("SimpleData", SimpleData::class) {
-//         "a" to FieldType.Integer
-//         "b" to FieldType.Integer
-//     }
+    val SIMPLE_DATA_DTD = dataTypeDescriptor("SimpleData", SimpleData::class) {
+        "a" to FieldType.Integer
+        "b" to FieldType.Integer
+    }
 
-//     val MY_POLICY = policy("MyPolicy", "Any") {
-//         description = "Testing policy builder"
-//         target(dataTypeDescriptor = FOOBAR_DTD, maxAge = Duration.ofMinutes(15)) {
-//             retention(StorageMedium.RAM)
-//             "name" { rawUsage(UsageType.ANY) }
-//         }
+    val MY_POLICY = policy("MyPolicy", "Any") {
+        description = "Testing policy builder"
+        target(dataTypeDescriptor = FOOBAR_DTD, maxAge = Duration.ofMinutes(15)) {
+            retention(StorageMedium.RAM)
+            "name" { rawUsage(UsageType.ANY) }
+        }
 
-//         target(dataTypeDescriptor = SIMPLE_DATA_DTD, maxAge = Duration.ofDays(2)) {
-//             retention(StorageMedium.DISK, encryptionRequired = true)
-//             "a" { rawUsage(UsageType.ANY) }
-//             "b" { rawUsage(UsageType.JOIN) }
-//         }
+        target(dataTypeDescriptor = SIMPLE_DATA_DTD, maxAge = Duration.ofDays(2)) {
+            retention(StorageMedium.DISK, encryptionRequired = true)
+            "a" { rawUsage(UsageType.ANY) }
+            "b" { rawUsage(UsageType.JOIN) }
+        }
 
-//         config("test") { "key" to "value" }
-//     }
+        config("test") { "key" to "value" }
+    }
 
-//     @Test
-//     fun testPolicyBuilder() {
-//         assertThat(MY_POLICY.name).isEqualTo("MyPolicy")
-//         assertThat(MY_POLICY.egressType).isEqualTo("Any")
-//         // should be two targets
-//         assertThat(MY_POLICY.targets).containsExactly(
-//             target(dataTypeDescriptor = FOOBAR_DTD, maxAge = Duration.ofMinutes(15)) {
-//                 retention(StorageMedium.RAM)
-//                 "name" { rawUsage(UsageType.ANY) }
-//             },
-//             target(dataTypeDescriptor = SIMPLE_DATA_DTD, maxAge = Duration.ofDays(2)) {
-//                 retention(StorageMedium.DISK, encryptionRequired = true)
-//                 "a" { rawUsage(UsageType.ANY) }
-//                 "b" { rawUsage(UsageType.JOIN) }
-//             }
-//         )
-//         // one config key-value pair
-//         assertThat(MY_POLICY.configs).containsExactly(
-//             "test",
-//             PolicyConfigBuilder().apply { "key" to "value" }.build()
-//         )
-//     }
-// }
\ No newline at end of file
+    @Test
+    fun testPolicyBuilder() {
+        assertThat(MY_POLICY.name).isEqualTo("MyPolicy")
+        assertThat(MY_POLICY.egressType).isEqualTo("Any")
+        // should be two targets
+        assertThat(MY_POLICY.targets).containsExactly(
+            target(dataTypeDescriptor = FOOBAR_DTD, maxAge = Duration.ofMinutes(15)) {
+                retention(StorageMedium.RAM)
+                "name" { rawUsage(UsageType.ANY) }
+            },
+            target(dataTypeDescriptor = SIMPLE_DATA_DTD, maxAge = Duration.ofDays(2)) {
+                retention(StorageMedium.DISK, encryptionRequired = true)
+                "a" { rawUsage(UsageType.ANY) }
+                "b" { rawUsage(UsageType.JOIN) }
+            }
+        )
+        // one config key-value pair
+        assertThat(MY_POLICY.configs).containsExactly(
+            "test",
+            PolicyConfigBuilder().apply { "key" to "value" }.build()
+        )
+    }
+}
\ No newline at end of file
diff --git a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyCapabilitiesTest.kt b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyCapabilitiesTest.kt
index 796d09fc..57b2a5bb 100644
--- a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyCapabilitiesTest.kt
+++ b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyCapabilitiesTest.kt
@@ -14,211 +14,211 @@
  * limitations under the License.
  */
 
-// package com.android.libraries.pcc.chronicle.test
+package com.android.libraries.pcc.chronicle.test
 
-// import androidx.test.core.app.ApplicationProvider
-// import androidx.test.ext.junit.runners.AndroidJUnit4
-// import androidx.test.ext.truth.os.ParcelableSubject.assertThat
-// import org.junit.Test
-// import org.junit.runner.RunWith
-// import com.google.common.truth.Truth.assertThat
-// import kotlin.test.assertFailsWith
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capabilities
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Encryption
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Persistence
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Queryable
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Range
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Shareable
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Ttl
-// import com.android.libraries.pcc.chronicle.api.policy.annotation.Annotation
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.ext.truth.os.ParcelableSubject.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import com.google.common.truth.Truth.assertThat
+import kotlin.test.assertFailsWith
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capabilities
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Encryption
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Persistence
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Queryable
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Range
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Shareable
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Ttl
+import com.android.libraries.pcc.chronicle.api.policy.annotation.Annotation
 
-// /**
-//  * Test of [Capabilities.kt].
-//  */
-// @RunWith(AndroidJUnit4::class)
-// class ChronicleApiPolicyCapabilitiesTest {
-//     @Test
-//     fun testCapabilitiesEmpty() {
-//         assertThat(Capabilities().isEmpty).isTrue()
-//         assertThat(Capabilities.fromAnnotations(emptyList<Annotation>()).isEmpty).isTrue()
-//         assertThat(Capabilities(Persistence.ON_DISK).isEmpty).isFalse()
-//         assertThat(Capabilities(listOf(Persistence.ON_DISK)).isEmpty).isFalse()
-//     }
+/**
+ * Test of [Capabilities.kt].
+ */
+@RunWith(AndroidJUnit4::class)
+class ChronicleApiPolicyCapabilitiesTest {
+    @Test
+    fun testCapabilitiesEmpty() {
+        assertThat(Capabilities().isEmpty).isTrue()
+        assertThat(Capabilities.fromAnnotations(emptyList<Annotation>()).isEmpty).isTrue()
+        assertThat(Capabilities(Persistence.ON_DISK).isEmpty).isFalse()
+        assertThat(Capabilities(listOf(Persistence.ON_DISK)).isEmpty).isFalse()
+    }
 
-//     @Test
-//     fun testCapabilitiesUnique() {
-//         assertFailsWith<IllegalArgumentException> {
-//         Capabilities(listOf(Ttl.Days(1).toRange(), Ttl.Hours(3)))
-//         }
-//     }
+    @Test
+    fun testCapabilitiesUnique() {
+        assertFailsWith<IllegalArgumentException> {
+        Capabilities(listOf(Ttl.Days(1).toRange(), Ttl.Hours(3)))
+        }
+    }
 
-//     @Test
-//     fun testCapabilitiesFromAnnotationsPersistent() {
-//         val persistent = Capabilities.fromAnnotation(Annotation.createCapability("persistent"))
-//         assertThat(persistent.persistence).isEqualTo(Persistence.ON_DISK)
-//         assertThat(persistent.isEncrypted).isNull()
-//         assertThat(persistent.ttl).isNull()
-//         assertThat(persistent.isQueryable).isNull()
-//         assertThat(persistent.isShareable).isNull()
-//     }
+    @Test
+    fun testCapabilitiesFromAnnotationsPersistent() {
+        val persistent = Capabilities.fromAnnotation(Annotation.createCapability("persistent"))
+        assertThat(persistent.persistence).isEqualTo(Persistence.ON_DISK)
+        assertThat(persistent.isEncrypted).isNull()
+        assertThat(persistent.ttl).isNull()
+        assertThat(persistent.isQueryable).isNull()
+        assertThat(persistent.isShareable).isNull()
+    }
 
-//     @Test
-//     fun testCapabilitiesFromAnnotationsTtl() {
-//         val ttl30d = Capabilities.fromAnnotation(Annotation.createTtl("30d"))
-//         assertThat(ttl30d.persistence).isNull()
-//         assertThat(ttl30d.isEncrypted).isNull()
-//         assertThat(ttl30d.ttl).isEqualTo(Capability.Ttl.Days(30))
-//         assertThat(ttl30d.isQueryable).isNull()
-//         assertThat(ttl30d.isShareable).isNull()
-//     }
+    @Test
+    fun testCapabilitiesFromAnnotationsTtl() {
+        val ttl30d = Capabilities.fromAnnotation(Annotation.createTtl("30d"))
+        assertThat(ttl30d.persistence).isNull()
+        assertThat(ttl30d.isEncrypted).isNull()
+        assertThat(ttl30d.ttl).isEqualTo(Capability.Ttl.Days(30))
+        assertThat(ttl30d.isQueryable).isNull()
+        assertThat(ttl30d.isShareable).isNull()
+    }
 
-//     @Test
-//     fun testCapabilitiesFromAnnotationsPersistentAndTtl() {
-//         val persistentAndTtl30d =
-//         Capabilities.fromAnnotations(
-//             listOf(Annotation.createCapability("persistent"), Annotation.createTtl("30d"))
-//         )
-//         assertThat(persistentAndTtl30d.persistence).isEqualTo(Persistence.ON_DISK)
-//         assertThat(persistentAndTtl30d.isEncrypted).isNull()
-//         assertThat(persistentAndTtl30d.ttl).isEqualTo(Capability.Ttl.Days(30))
-//         assertThat(persistentAndTtl30d.isQueryable).isNull()
-//         assertThat(persistentAndTtl30d.isShareable).isNull()
-//     }
+    @Test
+    fun testCapabilitiesFromAnnotationsPersistentAndTtl() {
+        val persistentAndTtl30d =
+        Capabilities.fromAnnotations(
+            listOf(Annotation.createCapability("persistent"), Annotation.createTtl("30d"))
+        )
+        assertThat(persistentAndTtl30d.persistence).isEqualTo(Persistence.ON_DISK)
+        assertThat(persistentAndTtl30d.isEncrypted).isNull()
+        assertThat(persistentAndTtl30d.ttl).isEqualTo(Capability.Ttl.Days(30))
+        assertThat(persistentAndTtl30d.isQueryable).isNull()
+        assertThat(persistentAndTtl30d.isShareable).isNull()
+    }
 
-//     @Test
-//     fun testCapabilitiesFromAnnotationsQueryableAndEncrypted() {
-//         val queryableEncrypted =
-//         Capabilities.fromAnnotations(
-//             listOf(Annotation.createCapability("encrypted"), Annotation.createCapability("queryable"))
-//         )
-//         assertThat(queryableEncrypted.persistence).isNull()
-//         assertThat(queryableEncrypted.isEncrypted).isTrue()
-//         assertThat(queryableEncrypted.ttl).isNull()
-//         assertThat(queryableEncrypted.isQueryable).isTrue()
-//         assertThat(queryableEncrypted.isShareable).isNull()
-//     }
+    @Test
+    fun testCapabilitiesFromAnnotationsQueryableAndEncrypted() {
+        val queryableEncrypted =
+        Capabilities.fromAnnotations(
+            listOf(Annotation.createCapability("encrypted"), Annotation.createCapability("queryable"))
+        )
+        assertThat(queryableEncrypted.persistence).isNull()
+        assertThat(queryableEncrypted.isEncrypted).isTrue()
+        assertThat(queryableEncrypted.ttl).isNull()
+        assertThat(queryableEncrypted.isQueryable).isTrue()
+        assertThat(queryableEncrypted.isShareable).isNull()
+    }
 
-//     @Test
-//     fun testCapabilitiesFromAnnotationsTiedToRuntimeAndTtl() {
-//         val tiedToRuntime = Capabilities.fromAnnotation(Annotation.createCapability("tiedToRuntime"))
-//         assertThat(tiedToRuntime.persistence).isEqualTo(Persistence.IN_MEMORY)
-//         assertThat(tiedToRuntime.isEncrypted).isNull()
-//         assertThat(tiedToRuntime.ttl).isNull()
-//         assertThat(tiedToRuntime.isQueryable).isNull()
-//         assertThat(tiedToRuntime.isShareable).isTrue()
-//     }
+    @Test
+    fun testCapabilitiesFromAnnotationsTiedToRuntimeAndTtl() {
+        val tiedToRuntime = Capabilities.fromAnnotation(Annotation.createCapability("tiedToRuntime"))
+        assertThat(tiedToRuntime.persistence).isEqualTo(Persistence.IN_MEMORY)
+        assertThat(tiedToRuntime.isEncrypted).isNull()
+        assertThat(tiedToRuntime.ttl).isNull()
+        assertThat(tiedToRuntime.isQueryable).isNull()
+        assertThat(tiedToRuntime.isShareable).isTrue()
+    }
 
-//     @Test
-//     fun testCapabilitiesContains() {
-//         val capabilities = Capabilities(
-//             listOf<Capability.Range>(
-//                 Persistence.ON_DISK.toRange(),
-//                 Capability.Range(Capability.Ttl.Days(30), Capability.Ttl.Hours(1)),
-//                 Capability.Queryable(true).toRange()
-//             )
-//         )
-//         assertThat(capabilities.contains(Persistence.ON_DISK)).isTrue()
-//         assertThat(capabilities.contains(Persistence.UNRESTRICTED)).isFalse()
-//         assertThat(capabilities.contains(Persistence.IN_MEMORY)).isFalse()
-//         assertThat(capabilities.contains(Capability.Ttl.Minutes(15))).isFalse()
-//         assertThat(capabilities.contains(Capability.Ttl.Hours(2))).isTrue()
-//         assertThat(capabilities.contains(Capability.Ttl.Days(30))).isTrue()
-//         assertThat(
-//             capabilities.contains(Capability.Range(Capability.Ttl.Days(20), Capability.Ttl.Hours(15)))
-//         )
-//         .isTrue()
-//         assertThat(capabilities.contains(Capability.Queryable(true))).isTrue()
-//         assertThat(capabilities.contains(Capability.Queryable(false))).isFalse()
-//         assertThat(capabilities.contains(Capability.Encryption(true))).isFalse()
-//         assertThat(capabilities.contains(Capability.Encryption(false))).isFalse()
+    @Test
+    fun testCapabilitiesContains() {
+        val capabilities = Capabilities(
+            listOf<Capability.Range>(
+                Persistence.ON_DISK.toRange(),
+                Capability.Range(Capability.Ttl.Days(30), Capability.Ttl.Hours(1)),
+                Capability.Queryable(true).toRange()
+            )
+        )
+        assertThat(capabilities.contains(Persistence.ON_DISK)).isTrue()
+        assertThat(capabilities.contains(Persistence.UNRESTRICTED)).isFalse()
+        assertThat(capabilities.contains(Persistence.IN_MEMORY)).isFalse()
+        assertThat(capabilities.contains(Capability.Ttl.Minutes(15))).isFalse()
+        assertThat(capabilities.contains(Capability.Ttl.Hours(2))).isTrue()
+        assertThat(capabilities.contains(Capability.Ttl.Days(30))).isTrue()
+        assertThat(
+            capabilities.contains(Capability.Range(Capability.Ttl.Days(20), Capability.Ttl.Hours(15)))
+        )
+        .isTrue()
+        assertThat(capabilities.contains(Capability.Queryable(true))).isTrue()
+        assertThat(capabilities.contains(Capability.Queryable(false))).isFalse()
+        assertThat(capabilities.contains(Capability.Encryption(true))).isFalse()
+        assertThat(capabilities.contains(Capability.Encryption(false))).isFalse()
 
-//         assertThat(capabilities.containsAll(capabilities)).isTrue()
-//         assertThat(
-//             capabilities.containsAll(
-//                 Capabilities(
-//                     listOf<Capability.Range>(
-//                         Persistence.ON_DISK.toRange(),
-//                         Capability.Ttl.Days(10).toRange()
-//                     )
-//                 )
-//             )
-//         )
-//         .isTrue()
-//         assertThat(
-//             capabilities.containsAll(
-//                 Capabilities(
-//                     listOf<Capability.Range>(
-//                         Capability.Ttl.Days(10).toRange(),
-//                         Capability.Shareable(true).toRange()
-//                     )
-//                 )
-//             )
-//         )
-//         .isFalse()
-//         assertThat(
-//             capabilities.containsAll(Capabilities(listOf<Capability.Range>(Capability.Queryable.ANY)))
-//         )
-//         .isFalse()
-//     }
+        assertThat(capabilities.containsAll(capabilities)).isTrue()
+        assertThat(
+            capabilities.containsAll(
+                Capabilities(
+                    listOf<Capability.Range>(
+                        Persistence.ON_DISK.toRange(),
+                        Capability.Ttl.Days(10).toRange()
+                    )
+                )
+            )
+        )
+        .isTrue()
+        assertThat(
+            capabilities.containsAll(
+                Capabilities(
+                    listOf<Capability.Range>(
+                        Capability.Ttl.Days(10).toRange(),
+                        Capability.Shareable(true).toRange()
+                    )
+                )
+            )
+        )
+        .isFalse()
+        assertThat(
+            capabilities.containsAll(Capabilities(listOf<Capability.Range>(Capability.Queryable.ANY)))
+        )
+        .isFalse()
+    }
 
-//     @Test
-//     fun testCapabilitiesIsEquivalent() {
-//         val capabilities = Capabilities(listOf(Capability.Range(Ttl.Days(10), Ttl.Days(2))))
-//         assertThat(capabilities.contains(Ttl.Days(5))).isTrue()
-//         assertThat(capabilities.contains(Capability.Range(Ttl.Days(9), Ttl.Days(2)))).isTrue()
-//         assertThat(capabilities.containsAll(Capabilities(listOf(Ttl.Days(5))))).isTrue()
-//         assertThat(
-//             capabilities.containsAll(Capabilities(listOf(Capability.Range(Ttl.Days(9), Ttl.Days(2)))))
-//         )
-//         .isTrue()
-//         assertThat(capabilities.isEquivalent(Capabilities(listOf(Ttl.Days(5))))).isFalse()
-//         assertThat(
-//             capabilities.isEquivalent(Capabilities(listOf(Capability.Range(Ttl.Days(9), Ttl.Days(2)))))
-//         )
-//         .isFalse()
-//         assertThat(capabilities.hasEquivalent(Capability.Range(Ttl.Days(10), Ttl.Days(2)))).isTrue()
-//         assertThat(
-//             capabilities.isEquivalent(Capabilities(listOf(Capability.Range(Ttl.Days(10), Ttl.Days(2)))))
-//         )
-//         .isTrue()
-//     }
+    @Test
+    fun testCapabilitiesIsEquivalent() {
+        val capabilities = Capabilities(listOf(Capability.Range(Ttl.Days(10), Ttl.Days(2))))
+        assertThat(capabilities.contains(Ttl.Days(5))).isTrue()
+        assertThat(capabilities.contains(Capability.Range(Ttl.Days(9), Ttl.Days(2)))).isTrue()
+        assertThat(capabilities.containsAll(Capabilities(listOf(Ttl.Days(5))))).isTrue()
+        assertThat(
+            capabilities.containsAll(Capabilities(listOf(Capability.Range(Ttl.Days(9), Ttl.Days(2)))))
+        )
+        .isTrue()
+        assertThat(capabilities.isEquivalent(Capabilities(listOf(Ttl.Days(5))))).isFalse()
+        assertThat(
+            capabilities.isEquivalent(Capabilities(listOf(Capability.Range(Ttl.Days(9), Ttl.Days(2)))))
+        )
+        .isFalse()
+        assertThat(capabilities.hasEquivalent(Capability.Range(Ttl.Days(10), Ttl.Days(2)))).isTrue()
+        assertThat(
+            capabilities.isEquivalent(Capabilities(listOf(Capability.Range(Ttl.Days(10), Ttl.Days(2)))))
+        )
+        .isTrue()
+    }
 
-//     @Test
-//     fun testCapabilitiesIsEquivalentMultipleRanges() {
-//         val capabilities = Capabilities(listOf(Persistence.ON_DISK, Capability.Range(Ttl.Days(10), Ttl.Days(2))))
-//         assertThat(capabilities.contains(Ttl.Days(5))).isTrue()
-//         assertThat(capabilities.contains(Capability.Range(Ttl.Days(9), Ttl.Days(2)))).isTrue()
-//         assertThat(capabilities.containsAll(Capabilities(listOf(Ttl.Days(5))))).isTrue()
-//         assertThat(
-//             capabilities.containsAll(Capabilities(listOf(Capability.Range(Ttl.Days(9), Ttl.Days(2)))))
-//         )
-//         .isTrue()
-//         assertThat(capabilities.isEquivalent(Capabilities(listOf(Ttl.Days(5))))).isFalse()
-//         assertThat(
-//             capabilities.isEquivalent(Capabilities(listOf(Capability.Range(Ttl.Days(9), Ttl.Days(2)))))
-//         )
-//         .isFalse()
-//         assertThat(
-//             capabilities.isEquivalent(Capabilities(listOf(Capability.Range(Ttl.Days(10), Ttl.Days(2)))))
-//         )
-//         .isFalse()
-//         assertThat(capabilities.hasEquivalent(Capability.Range(Ttl.Days(10), Ttl.Days(2)))).isTrue()
-//         assertThat(capabilities.hasEquivalent(Persistence.IN_MEMORY)).isFalse()
-//         assertThat(capabilities.hasEquivalent(Persistence.ON_DISK)).isTrue()
-//         assertThat(capabilities.containsAll(Capabilities(listOf(Persistence.ON_DISK, Ttl.Days(10)))))
-//         .isTrue()
-//         assertThat(
-//             capabilities.containsAll(Capabilities(listOf(Persistence.ON_DISK, Encryption(true))))
-//         )
-//         .isFalse()
-//         assertThat(capabilities.isEquivalent(Capabilities(listOf(Persistence.ON_DISK, Ttl.Days(10)))))
-//         .isFalse()
-//         assertThat(
-//             capabilities.isEquivalent(
-//             Capabilities(listOf(Persistence.ON_DISK, Capability.Range(Ttl.Days(10), Ttl.Days(2))))
-//             )
-//         )
-//         .isTrue()
-//     }
-// }
\ No newline at end of file
+    @Test
+    fun testCapabilitiesIsEquivalentMultipleRanges() {
+        val capabilities = Capabilities(listOf(Persistence.ON_DISK, Capability.Range(Ttl.Days(10), Ttl.Days(2))))
+        assertThat(capabilities.contains(Ttl.Days(5))).isTrue()
+        assertThat(capabilities.contains(Capability.Range(Ttl.Days(9), Ttl.Days(2)))).isTrue()
+        assertThat(capabilities.containsAll(Capabilities(listOf(Ttl.Days(5))))).isTrue()
+        assertThat(
+            capabilities.containsAll(Capabilities(listOf(Capability.Range(Ttl.Days(9), Ttl.Days(2)))))
+        )
+        .isTrue()
+        assertThat(capabilities.isEquivalent(Capabilities(listOf(Ttl.Days(5))))).isFalse()
+        assertThat(
+            capabilities.isEquivalent(Capabilities(listOf(Capability.Range(Ttl.Days(9), Ttl.Days(2)))))
+        )
+        .isFalse()
+        assertThat(
+            capabilities.isEquivalent(Capabilities(listOf(Capability.Range(Ttl.Days(10), Ttl.Days(2)))))
+        )
+        .isFalse()
+        assertThat(capabilities.hasEquivalent(Capability.Range(Ttl.Days(10), Ttl.Days(2)))).isTrue()
+        assertThat(capabilities.hasEquivalent(Persistence.IN_MEMORY)).isFalse()
+        assertThat(capabilities.hasEquivalent(Persistence.ON_DISK)).isTrue()
+        assertThat(capabilities.containsAll(Capabilities(listOf(Persistence.ON_DISK, Ttl.Days(10)))))
+        .isTrue()
+        assertThat(
+            capabilities.containsAll(Capabilities(listOf(Persistence.ON_DISK, Encryption(true))))
+        )
+        .isFalse()
+        assertThat(capabilities.isEquivalent(Capabilities(listOf(Persistence.ON_DISK, Ttl.Days(10)))))
+        .isFalse()
+        assertThat(
+            capabilities.isEquivalent(
+            Capabilities(listOf(Persistence.ON_DISK, Capability.Range(Ttl.Days(10), Ttl.Days(2))))
+            )
+        )
+        .isTrue()
+    }
+}
\ No newline at end of file
diff --git a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyFieldBuilderTest.kt b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyFieldBuilderTest.kt
index be1b79af..00d079d0 100644
--- a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyFieldBuilderTest.kt
+++ b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyFieldBuilderTest.kt
@@ -14,140 +14,140 @@
  * limitations under the License.
  */
 
-// package com.android.libraries.pcc.chronicle.test
+package com.android.libraries.pcc.chronicle.test
 
-// import androidx.test.core.app.ApplicationProvider
-// import androidx.test.ext.junit.runners.AndroidJUnit4
-// import androidx.test.ext.truth.os.ParcelableSubject.assertThat
-// import org.junit.Test
-// import org.junit.runner.RunWith
-// import com.android.libraries.pcc.chronicle.api.policy.Policy
-// import com.android.libraries.pcc.chronicle.test.data.NestedPerson
-// import com.android.libraries.pcc.chronicle.test.data.NestedPet
-// import com.android.libraries.pcc.chronicle.api.policy.builder.policy
-// import com.android.libraries.pcc.chronicle.api.policy.builder.target
-// import com.android.libraries.pcc.chronicle.api.policy.builder.ConditionalUsage
-// import com.android.libraries.pcc.chronicle.api.policy.StorageMedium
-// import com.android.libraries.pcc.chronicle.api.policy.PolicyTarget
-// import com.android.libraries.pcc.chronicle.api.policy.PolicyField
-// import com.android.libraries.pcc.chronicle.api.FieldType
-// import com.android.libraries.pcc.chronicle.api.policy.UsageType
-// import com.android.libraries.pcc.chronicle.api.policy.builder.PolicyFieldBuilder
-// import com.android.libraries.pcc.chronicle.api.dataTypeDescriptor
-// import com.google.common.truth.Truth.assertThat
-// import java.time.Duration
-// import kotlin.test.assertFailsWith
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.ext.truth.os.ParcelableSubject.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import com.android.libraries.pcc.chronicle.api.policy.Policy
+import com.android.libraries.pcc.chronicle.test.data.NestedPerson
+import com.android.libraries.pcc.chronicle.test.data.NestedPet
+import com.android.libraries.pcc.chronicle.api.policy.builder.policy
+import com.android.libraries.pcc.chronicle.api.policy.builder.target
+import com.android.libraries.pcc.chronicle.api.policy.builder.ConditionalUsage
+import com.android.libraries.pcc.chronicle.api.policy.StorageMedium
+import com.android.libraries.pcc.chronicle.api.policy.PolicyTarget
+import com.android.libraries.pcc.chronicle.api.policy.PolicyField
+import com.android.libraries.pcc.chronicle.api.FieldType
+import com.android.libraries.pcc.chronicle.api.policy.UsageType
+import com.android.libraries.pcc.chronicle.api.policy.builder.PolicyFieldBuilder
+import com.android.libraries.pcc.chronicle.api.dataTypeDescriptor
+import com.google.common.truth.Truth.assertThat
+import java.time.Duration
+import kotlin.test.assertFailsWith
 
-// /**
-//  * Test of building Chronicle [PolicyField] using [PolicyFieldBuilder].
-//  */
-// @RunWith(AndroidJUnit4::class)
-// class ChronicleApiPolicyFieldBuilderTest {
+/**
+ * Test of building Chronicle [PolicyField] using [PolicyFieldBuilder].
+ */
+@RunWith(AndroidJUnit4::class)
+class ChronicleApiPolicyFieldBuilderTest {
 
-//     val NESTED_PERSON_GENERATED_DTD = dataTypeDescriptor("NestedPerson", NestedPerson::class) {
-//         "name" to FieldType.String
-//         "age" to FieldType.Integer
-//         "pets" to dataTypeDescriptor("NestedPet", NestedPet::class) {
-//             "breed" to FieldType.String
-//         }
-//     }
+    val NESTED_PERSON_GENERATED_DTD = dataTypeDescriptor("NestedPerson", NestedPerson::class) {
+        "name" to FieldType.String
+        "age" to FieldType.Integer
+        "pets" to dataTypeDescriptor("NestedPet", NestedPet::class) {
+            "breed" to FieldType.String
+        }
+    }
 
-//     @Test
-//     fun testRawUsage() {
-//         val actual = PolicyFieldBuilder(null, listOf("foo"))
-//                 .apply { rawUsage(UsageType.JOIN, UsageType.EGRESS) }
-//                 .build()
-//         assertThat(actual.fieldPath).containsExactly("foo").inOrder()
-//         assertThat(actual.rawUsages).containsExactly(UsageType.JOIN, UsageType.EGRESS)
-//     }
+    @Test
+    fun testRawUsage() {
+        val actual = PolicyFieldBuilder(null, listOf("foo"))
+                .apply { rawUsage(UsageType.JOIN, UsageType.EGRESS) }
+                .build()
+        assertThat(actual.fieldPath).containsExactly("foo").inOrder()
+        assertThat(actual.rawUsages).containsExactly(UsageType.JOIN, UsageType.EGRESS)
+    }
 
-//     @Test
-//     fun testConditionalUsage() {
-//         val stringApi = PolicyFieldBuilder(null, listOf("foo"))
-//             .apply {
-//                 conditionalUsage("bucketed", UsageType.JOIN, UsageType.EGRESS)
-//                 conditionalUsage("truncatedToDays", UsageType.ANY)
-//             }
-//             .build()
-//         val enumApi = PolicyFieldBuilder(null, listOf("foo"))
-//             .apply {
-//                 ConditionalUsage.Bucketed.whenever(UsageType.JOIN, UsageType.EGRESS)
-//                 ConditionalUsage.TruncatedToDays.whenever(UsageType.ANY)
-//             }
-//             .build()
+    @Test
+    fun testConditionalUsage() {
+        val stringApi = PolicyFieldBuilder(null, listOf("foo"))
+            .apply {
+                conditionalUsage("bucketed", UsageType.JOIN, UsageType.EGRESS)
+                conditionalUsage("truncatedToDays", UsageType.ANY)
+            }
+            .build()
+        val enumApi = PolicyFieldBuilder(null, listOf("foo"))
+            .apply {
+                ConditionalUsage.Bucketed.whenever(UsageType.JOIN, UsageType.EGRESS)
+                ConditionalUsage.TruncatedToDays.whenever(UsageType.ANY)
+            }
+            .build()
 
-//         setOf(stringApi, enumApi).forEach { actual ->
-//             assertThat(actual.annotations).isEmpty()
-//             assertThat(actual.fieldPath).containsExactly("foo").inOrder()
-//             assertThat(actual.rawUsages).isEmpty()
-//             assertThat(actual.redactedUsages)
-//                 .containsExactly(
-//                 "bucketed",
-//                 setOf(UsageType.JOIN, UsageType.EGRESS),
-//                 "truncatedToDays",
-//                 setOf(UsageType.ANY)
-//                 )
-//             assertThat(actual.subfields).isEmpty()
-//         }
-//     }
+        setOf(stringApi, enumApi).forEach { actual ->
+            assertThat(actual.annotations).isEmpty()
+            assertThat(actual.fieldPath).containsExactly("foo").inOrder()
+            assertThat(actual.rawUsages).isEmpty()
+            assertThat(actual.redactedUsages)
+                .containsExactly(
+                "bucketed",
+                setOf(UsageType.JOIN, UsageType.EGRESS),
+                "truncatedToDays",
+                setOf(UsageType.ANY)
+                )
+            assertThat(actual.subfields).isEmpty()
+        }
+    }
 
-//     @Test
-//     fun testPolicyFields() {
-//         val actual = PolicyFieldBuilder(NESTED_PERSON_GENERATED_DTD, listOf("person"))
-//             .apply { "name" { rawUsage(UsageType.EGRESS) } }
-//             .build()
-//         assertThat(actual.annotations).isEmpty()
-//         assertThat(actual.fieldPath).containsExactly("person").inOrder()
-//         assertThat(actual.rawUsages).isEmpty()
-//         assertThat(actual.redactedUsages).isEmpty()
-//         assertThat(actual.subfields).containsExactly(
-//             PolicyField(fieldPath = listOf("person", "name"), rawUsages = setOf(UsageType.EGRESS)),
-//         )
-//     }
+    @Test
+    fun testPolicyFields() {
+        val actual = PolicyFieldBuilder(NESTED_PERSON_GENERATED_DTD, listOf("person"))
+            .apply { "name" { rawUsage(UsageType.EGRESS) } }
+            .build()
+        assertThat(actual.annotations).isEmpty()
+        assertThat(actual.fieldPath).containsExactly("person").inOrder()
+        assertThat(actual.rawUsages).isEmpty()
+        assertThat(actual.redactedUsages).isEmpty()
+        assertThat(actual.subfields).containsExactly(
+            PolicyField(fieldPath = listOf("person", "name"), rawUsages = setOf(UsageType.EGRESS)),
+        )
+    }
 
-//     @Test
-//     fun testPolicyFieldsWithSubFields() {
-//         val actual = PolicyFieldBuilder(NESTED_PERSON_GENERATED_DTD, listOf("person"))
-//             .apply {
-//                 "name" { rawUsage(UsageType.EGRESS) }
-//                 "pets" { "breed" { rawUsage(UsageType.ANY) } }
-//             }
-//             .build()
-//         assertThat(actual.annotations).isEmpty()
-//         assertThat(actual.fieldPath).containsExactly("person").inOrder()
-//         assertThat(actual.rawUsages).isEmpty()
-//         assertThat(actual.redactedUsages).isEmpty()
-//         assertThat(actual.subfields).containsExactly(
-//             PolicyField(fieldPath = listOf("person", "name"), rawUsages = setOf(UsageType.EGRESS)),
-//             PolicyField(
-//                 fieldPath = listOf("person", "pets"),
-//                 subfields = listOf(
-//                     PolicyField(
-//                         fieldPath = listOf("person", "pets", "breed"),
-//                         rawUsages = setOf(UsageType.ANY),
-//                     )
-//                 ),
-//             )
-//         )
-//     }
+    @Test
+    fun testPolicyFieldsWithSubFields() {
+        val actual = PolicyFieldBuilder(NESTED_PERSON_GENERATED_DTD, listOf("person"))
+            .apply {
+                "name" { rawUsage(UsageType.EGRESS) }
+                "pets" { "breed" { rawUsage(UsageType.ANY) } }
+            }
+            .build()
+        assertThat(actual.annotations).isEmpty()
+        assertThat(actual.fieldPath).containsExactly("person").inOrder()
+        assertThat(actual.rawUsages).isEmpty()
+        assertThat(actual.redactedUsages).isEmpty()
+        assertThat(actual.subfields).containsExactly(
+            PolicyField(fieldPath = listOf("person", "name"), rawUsages = setOf(UsageType.EGRESS)),
+            PolicyField(
+                fieldPath = listOf("person", "pets"),
+                subfields = listOf(
+                    PolicyField(
+                        fieldPath = listOf("person", "pets", "breed"),
+                        rawUsages = setOf(UsageType.ANY),
+                    )
+                ),
+            )
+        )
+    }
 
-//     @Test
-//     fun testInvalidFieldName() {
-//         val e = assertFailsWith<IllegalArgumentException> {
-//                 PolicyFieldBuilder(NESTED_PERSON_GENERATED_DTD, listOf("persons"))
-//                 .apply { "pet_typo" { "breed" { rawUsage(UsageType.ANY) } } }
-//                 .build()
-//             }
-//         assertThat(e).hasMessageThat().contains("Field 'pet_typo' not found in '${NESTED_PERSON_GENERATED_DTD.name}'")
-//     }
+    @Test
+    fun testInvalidFieldName() {
+        val e = assertFailsWith<IllegalArgumentException> {
+                PolicyFieldBuilder(NESTED_PERSON_GENERATED_DTD, listOf("persons"))
+                .apply { "pet_typo" { "breed" { rawUsage(UsageType.ANY) } } }
+                .build()
+            }
+        assertThat(e).hasMessageThat().contains("Field 'pet_typo' not found in '${NESTED_PERSON_GENERATED_DTD.name}'")
+    }
 
-//     @Test
-//     fun testNonexistField() {
-//         val e = assertFailsWith<IllegalArgumentException> {
-//                 PolicyFieldBuilder(NESTED_PERSON_GENERATED_DTD, listOf("persons"))
-//                 .apply { "pets" { "breed" { "nonexist" { rawUsage(UsageType.ANY) } } } }
-//                 .build()
-//             }
-//         assertThat(e).hasMessageThat().contains("Trying to lookup field 'nonexist' in a non-entity type.")
-//     }
-// }
\ No newline at end of file
+    @Test
+    fun testNonexistField() {
+        val e = assertFailsWith<IllegalArgumentException> {
+                PolicyFieldBuilder(NESTED_PERSON_GENERATED_DTD, listOf("persons"))
+                .apply { "pets" { "breed" { "nonexist" { rawUsage(UsageType.ANY) } } } }
+                .build()
+            }
+        assertThat(e).hasMessageThat().contains("Trying to lookup field 'nonexist' in a non-entity type.")
+    }
+}
\ No newline at end of file
diff --git a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyTargetBuilderTest.kt b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyTargetBuilderTest.kt
index 773eb42f..6fbdc5ad 100644
--- a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyTargetBuilderTest.kt
+++ b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyTargetBuilderTest.kt
@@ -14,56 +14,56 @@
  * limitations under the License.
  */
 
-// package com.android.libraries.pcc.chronicle.test
+package com.android.libraries.pcc.chronicle.test
 
-// import androidx.test.core.app.ApplicationProvider
-// import androidx.test.ext.junit.runners.AndroidJUnit4
-// import androidx.test.ext.truth.os.ParcelableSubject.assertThat
-// import org.junit.Test
-// import org.junit.runner.RunWith
-// import com.android.libraries.pcc.chronicle.api.policy.Policy
-// import com.android.libraries.pcc.chronicle.test.data.Foobar
-// import com.android.libraries.pcc.chronicle.api.policy.builder.policy
-// import com.android.libraries.pcc.chronicle.api.policy.builder.target
-// import com.android.libraries.pcc.chronicle.api.policy.StorageMedium
-// import com.android.libraries.pcc.chronicle.api.policy.PolicyTarget
-// import com.android.libraries.pcc.chronicle.api.policy.PolicyRetention
-// import com.android.libraries.pcc.chronicle.api.FieldType
-// import com.android.libraries.pcc.chronicle.api.policy.UsageType
-// import com.android.libraries.pcc.chronicle.api.policy.builder.PolicyFieldBuilder
-// import com.android.libraries.pcc.chronicle.api.dataTypeDescriptor
-// import com.google.common.truth.Truth.assertThat
-// import java.time.Duration
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.ext.truth.os.ParcelableSubject.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import com.android.libraries.pcc.chronicle.api.policy.Policy
+import com.android.libraries.pcc.chronicle.test.data.Foobar
+import com.android.libraries.pcc.chronicle.api.policy.builder.policy
+import com.android.libraries.pcc.chronicle.api.policy.builder.target
+import com.android.libraries.pcc.chronicle.api.policy.StorageMedium
+import com.android.libraries.pcc.chronicle.api.policy.PolicyTarget
+import com.android.libraries.pcc.chronicle.api.policy.PolicyRetention
+import com.android.libraries.pcc.chronicle.api.FieldType
+import com.android.libraries.pcc.chronicle.api.policy.UsageType
+import com.android.libraries.pcc.chronicle.api.policy.builder.PolicyFieldBuilder
+import com.android.libraries.pcc.chronicle.api.dataTypeDescriptor
+import com.google.common.truth.Truth.assertThat
+import java.time.Duration
 
-// /**
-//  * Test of building Chronicle [PolicyTarget] using [PolicyTargetBuilder].
-//  */
-// @RunWith(AndroidJUnit4::class)
-// class ChronicleApiPolicyTargetBuilderTest {
+/**
+ * Test of building Chronicle [PolicyTarget] using [PolicyTargetBuilder].
+ */
+@RunWith(AndroidJUnit4::class)
+class ChronicleApiPolicyTargetBuilderTest {
 
-//     val FOOBAR_DTD = dataTypeDescriptor("Foobar", Foobar::class) {
-//         "name" to FieldType.String
-//     }
+    val FOOBAR_DTD = dataTypeDescriptor("Foobar", Foobar::class) {
+        "name" to FieldType.String
+    }
 
-//     val FOOBAR_TARGET = target(dataTypeDescriptor = FOOBAR_DTD, maxAge = Duration.ofMinutes(15)) {
-//         retention(StorageMedium.RAM)
-//         "name" { rawUsage(UsageType.ANY) }
-//     }
+    val FOOBAR_TARGET = target(dataTypeDescriptor = FOOBAR_DTD, maxAge = Duration.ofMinutes(15)) {
+        retention(StorageMedium.RAM)
+        "name" { rawUsage(UsageType.ANY) }
+    }
 
-//     @Test
-//     fun testPolicyTargetBuilder() {
-//         // check all target fields for simple data structure
-//         assertThat(FOOBAR_TARGET.schemaName).isEqualTo("Foobar")
-//         // 15 minutes TTL
-//         assertThat(FOOBAR_TARGET.maxAgeMs).isEqualTo(900000)
-//         // RAM storage
-//         assertThat(FOOBAR_TARGET.retentions).containsExactly(
-//             PolicyRetention(StorageMedium.RAM)
-//         )
-//         // raw usage on a primitive fieldtype
-//         assertThat(FOOBAR_TARGET.fields).containsExactly(
-//             PolicyFieldBuilder(FOOBAR_DTD, listOf("name")).apply { rawUsage(UsageType.ANY) }.build()
-//         )
-//         assertThat(FOOBAR_TARGET.annotations).isEmpty()
-//     }
-// }
\ No newline at end of file
+    @Test
+    fun testPolicyTargetBuilder() {
+        // check all target fields for simple data structure
+        assertThat(FOOBAR_TARGET.schemaName).isEqualTo("Foobar")
+        // 15 minutes TTL
+        assertThat(FOOBAR_TARGET.maxAgeMs).isEqualTo(900000)
+        // RAM storage
+        assertThat(FOOBAR_TARGET.retentions).containsExactly(
+            PolicyRetention(StorageMedium.RAM)
+        )
+        // raw usage on a primitive fieldtype
+        assertThat(FOOBAR_TARGET.fields).containsExactly(
+            PolicyFieldBuilder(FOOBAR_DTD, listOf("name")).apply { rawUsage(UsageType.ANY) }.build()
+        )
+        assertThat(FOOBAR_TARGET.annotations).isEmpty()
+    }
+}
\ No newline at end of file
diff --git a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyTest.kt b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyTest.kt
index 709a293a..62c0ba0f 100644
--- a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyTest.kt
+++ b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiPolicyTest.kt
@@ -14,106 +14,106 @@
  * limitations under the License.
  */
 
-// package com.android.libraries.pcc.chronicle.test
+package com.android.libraries.pcc.chronicle.test
 
-// import androidx.test.core.app.ApplicationProvider
-// import androidx.test.ext.junit.runners.AndroidJUnit4
-// import androidx.test.ext.truth.os.ParcelableSubject.assertThat
-// import org.junit.Test
-// import org.junit.runner.RunWith
-// import com.android.libraries.pcc.chronicle.api.policy.Policy
-// import com.android.libraries.pcc.chronicle.api.policy.UsageType
-// import com.android.libraries.pcc.chronicle.api.policy.StorageMedium
-// import com.android.libraries.pcc.chronicle.api.policy.PolicyTarget
-// import com.android.libraries.pcc.chronicle.api.policy.PolicyField
-// import com.android.libraries.pcc.chronicle.api.policy.PolicyRetention
-// import com.google.common.truth.Truth.assertThat
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capabilities
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Encryption
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Persistence
-// import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Ttl
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.ext.truth.os.ParcelableSubject.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import com.android.libraries.pcc.chronicle.api.policy.Policy
+import com.android.libraries.pcc.chronicle.api.policy.UsageType
+import com.android.libraries.pcc.chronicle.api.policy.StorageMedium
+import com.android.libraries.pcc.chronicle.api.policy.PolicyTarget
+import com.android.libraries.pcc.chronicle.api.policy.PolicyField
+import com.android.libraries.pcc.chronicle.api.policy.PolicyRetention
+import com.google.common.truth.Truth.assertThat
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capabilities
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Encryption
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Persistence
+import com.android.libraries.pcc.chronicle.api.policy.capabilities.Capability.Ttl
 
-// /**
-//  * Test of Chronicle's [Policy] and its APIs.
-//  */
-// @RunWith(AndroidJUnit4::class)
-// class ChronicleApiPolicyTest {
-//     @Test
-//     fun testPolicyAllFields() {
-//         val child = PolicyField(listOf("parent", "child"))
-//         val parent = PolicyField(listOf("parent"), subfields = listOf(child))
-//         val other = PolicyField(listOf("other"))
-//         val policy = Policy(
-//             name = "MyPolicy",
-//             targets =
-//             listOf(
-//                 PolicyTarget("target1", fields = listOf(parent)),
-//                 PolicyTarget("target2", fields = listOf(other))
-//             ),
-//             egressType = "Logging"
-//         )
+/**
+ * Test of Chronicle's [Policy] and its APIs.
+ */
+@RunWith(AndroidJUnit4::class)
+class ChronicleApiPolicyTest {
+    @Test
+    fun testPolicyAllFields() {
+        val child = PolicyField(listOf("parent", "child"))
+        val parent = PolicyField(listOf("parent"), subfields = listOf(child))
+        val other = PolicyField(listOf("other"))
+        val policy = Policy(
+            name = "MyPolicy",
+            targets =
+            listOf(
+                PolicyTarget("target1", fields = listOf(parent)),
+                PolicyTarget("target2", fields = listOf(other))
+            ),
+            egressType = "Logging"
+        )
 
-//         assertThat(policy.allFields).containsExactly(child, parent, other)
-//     }
+        assertThat(policy.allFields).containsExactly(child, parent, other)
+    }
 
-//     @Test
-//     fun testPolicyAllRedactionLabels() {
-//         val child =
-//         PolicyField(
-//             fieldPath = listOf("parent", "child"),
-//             redactedUsages =
-//             mapOf("label1" to setOf(UsageType.EGRESS), "label2" to setOf(UsageType.JOIN))
-//         )
-//         val parent =
-//         PolicyField(
-//             fieldPath = listOf("parent"),
-//             subfields = listOf(child),
-//             redactedUsages =
-//             mapOf("label2" to setOf(UsageType.EGRESS), "label3" to setOf(UsageType.EGRESS))
-//         )
-//         val other =
-//         PolicyField(
-//             fieldPath = listOf("other"),
-//             redactedUsages = mapOf("label4" to setOf(UsageType.EGRESS))
-//         )
-//         val policy =
-//         Policy(
-//             name = "MyPolicy",
-//             targets =
-//             listOf(
-//                 PolicyTarget("target1", fields = listOf(parent)),
-//                 PolicyTarget("target2", fields = listOf(other))
-//             ),
-//             egressType = "Logging"
-//         )
+    @Test
+    fun testPolicyAllRedactionLabels() {
+        val child =
+        PolicyField(
+            fieldPath = listOf("parent", "child"),
+            redactedUsages =
+            mapOf("label1" to setOf(UsageType.EGRESS), "label2" to setOf(UsageType.JOIN))
+        )
+        val parent =
+        PolicyField(
+            fieldPath = listOf("parent"),
+            subfields = listOf(child),
+            redactedUsages =
+            mapOf("label2" to setOf(UsageType.EGRESS), "label3" to setOf(UsageType.EGRESS))
+        )
+        val other =
+        PolicyField(
+            fieldPath = listOf("other"),
+            redactedUsages = mapOf("label4" to setOf(UsageType.EGRESS))
+        )
+        val policy =
+        Policy(
+            name = "MyPolicy",
+            targets =
+            listOf(
+                PolicyTarget("target1", fields = listOf(parent)),
+                PolicyTarget("target2", fields = listOf(other))
+            ),
+            egressType = "Logging"
+        )
 
-//         assertThat(policy.allRedactionLabels).containsExactly("label1", "label2", "label3", "label4")
-//     }
+        assertThat(policy.allRedactionLabels).containsExactly("label1", "label2", "label3", "label4")
+    }
 
-//     @Test
-//     fun testPolicyTargetToCapabilities() {
-//         val policyTarget = PolicyTarget(
-//             schemaName = "schema",
-//             maxAgeMs = 2 * 60 * Ttl.MILLIS_IN_MIN, // 2 hours
-//             retentions =
-//             listOf(
-//                 PolicyRetention(medium = StorageMedium.DISK, encryptionRequired = true),
-//                 PolicyRetention(medium = StorageMedium.RAM)
-//             ),
-//             fields = emptyList(),
-//             annotations = emptyList()
-//         )
-//         val capabilities = policyTarget.toCapabilities()
-//         assertThat(capabilities).hasSize(2)
-//         assertThat(
-//             capabilities[0].isEquivalent(
-//                 Capabilities(listOf(Persistence.ON_DISK, Encryption(true), Ttl.Minutes(120)))
-//             )
-//         )
-//         .isTrue()
-//         assertThat(
-//             capabilities[1].isEquivalent(Capabilities(listOf(Persistence.IN_MEMORY, Ttl.Minutes(120))))
-//         )
-//         .isTrue()
-//     }
-// }
\ No newline at end of file
+    @Test
+    fun testPolicyTargetToCapabilities() {
+        val policyTarget = PolicyTarget(
+            schemaName = "schema",
+            maxAgeMs = 2 * 60 * Ttl.MILLIS_IN_MIN, // 2 hours
+            retentions =
+            listOf(
+                PolicyRetention(medium = StorageMedium.DISK, encryptionRequired = true),
+                PolicyRetention(medium = StorageMedium.RAM)
+            ),
+            fields = emptyList(),
+            annotations = emptyList()
+        )
+        val capabilities = policyTarget.toCapabilities()
+        assertThat(capabilities).hasSize(2)
+        assertThat(
+            capabilities[0].isEquivalent(
+                Capabilities(listOf(Persistence.ON_DISK, Encryption(true), Ttl.Minutes(120)))
+            )
+        )
+        .isTrue()
+        assertThat(
+            capabilities[1].isEquivalent(Capabilities(listOf(Persistence.IN_MEMORY, Ttl.Minutes(120))))
+        )
+        .isTrue()
+    }
+}
\ No newline at end of file
diff --git a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiStorageTest.kt b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiStorageTest.kt
index 4d430f89..eff445ba 100644
--- a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiStorageTest.kt
+++ b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/ChronicleApiStorageTest.kt
@@ -14,75 +14,75 @@
  * limitations under the License.
  */
 
-// package com.android.libraries.pcc.chronicle.test
+package com.android.libraries.pcc.chronicle.test
 
-// import androidx.test.core.app.ApplicationProvider
-// import androidx.test.ext.junit.runners.AndroidJUnit4
-// import androidx.test.ext.truth.os.ParcelableSubject.assertThat
-// import com.android.libraries.pcc.chronicle.api.storage.EntityMetadata
-// import com.android.libraries.pcc.chronicle.api.storage.WrappedEntity
-// import com.android.libraries.pcc.chronicle.api.storage.Timestamp
-// import com.android.libraries.pcc.chronicle.api.storage.toInstant
-// import com.android.libraries.pcc.chronicle.api.storage.toProtoTimestamp
-// import com.android.libraries.pcc.chronicle.api.storage.update
-// import com.android.libraries.pcc.chronicle.test.data.Foobar
-// import com.google.common.truth.Truth.assertThat
-// import java.time.Instant
-// import kotlin.test.assertFailsWith
-// import org.junit.Test
-// import org.junit.runner.RunWith
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.ext.truth.os.ParcelableSubject.assertThat
+import com.android.libraries.pcc.chronicle.api.storage.EntityMetadata
+import com.android.libraries.pcc.chronicle.api.storage.WrappedEntity
+import com.android.libraries.pcc.chronicle.api.storage.Timestamp
+import com.android.libraries.pcc.chronicle.api.storage.toInstant
+import com.android.libraries.pcc.chronicle.api.storage.toProtoTimestamp
+import com.android.libraries.pcc.chronicle.api.storage.update
+import com.android.libraries.pcc.chronicle.test.data.Foobar
+import com.google.common.truth.Truth.assertThat
+import java.time.Instant
+import kotlin.test.assertFailsWith
+import org.junit.Test
+import org.junit.runner.RunWith
 
-// /** Tests for Chronicle Api storage classes. */
-// @RunWith(AndroidJUnit4::class)
-// class ChronicleApiStorageTest {
-//     @Test
-//     fun testInstantToTimestamp() {
-//         val instant1 = Instant.ofEpochMilli(999000)
-//         val timestamp1 = instant1.toProtoTimestamp()
-//         assertThat(timestamp1.getSeconds()).isEqualTo(999)
-//         assertThat(timestamp1.getNanos()).isEqualTo(0)
-//     }
+/** Tests for Chronicle Api storage classes. */
+@RunWith(AndroidJUnit4::class)
+class ChronicleApiStorageTest {
+    @Test
+    fun testInstantToTimestamp() {
+        val instant1 = Instant.ofEpochMilli(999000)
+        val timestamp1 = instant1.toProtoTimestamp()
+        assertThat(timestamp1.getSeconds()).isEqualTo(999)
+        assertThat(timestamp1.getNanos()).isEqualTo(0)
+    }
 
-//     @Test
-//     fun testTimestampToInstant() {
-//         val timestamp1 = Timestamp.newBuilder().setSeconds(901).setNanos(101).build()
-//         val instant1 = timestamp1.toInstant()
-//         assertThat(instant1.getEpochSecond()).isEqualTo(901)
-//         assertThat(instant1.getNano()).isEqualTo(101)
-//     }
+    @Test
+    fun testTimestampToInstant() {
+        val timestamp1 = Timestamp.newBuilder().setSeconds(901).setNanos(101).build()
+        val instant1 = timestamp1.toInstant()
+        assertThat(instant1.getEpochSecond()).isEqualTo(901)
+        assertThat(instant1.getNano()).isEqualTo(101)
+    }
 
-//     @Test
-//     fun testEntityMetadataUpdateList() {
-//         val oldEntityMetadata = EntityMetadata("ID", listOf("a", "b"), Instant.ofEpochMilli(999000), Instant.ofEpochMilli(1000000))
+    @Test
+    fun testEntityMetadataUpdateList() {
+        val oldEntityMetadata = EntityMetadata("ID", listOf("a", "b"), Instant.ofEpochMilli(999000), Instant.ofEpochMilli(1000000))
 
-//         val instantUpdated = Instant.ofEpochMilli(1100000)
-//         val associatedPackageNames = listOf("aa", "bb")
+        val instantUpdated = Instant.ofEpochMilli(1100000)
+        val associatedPackageNames = listOf("aa", "bb")
 
-//         val newEntityMetadata = oldEntityMetadata.update(instantUpdated, associatedPackageNames)
-//         assertThat(newEntityMetadata.updated).isEqualTo(instantUpdated.toProtoTimestamp())
-//         assertThat(newEntityMetadata.associatedPackageNamesCount).isEqualTo(2)
-//         assertThat(newEntityMetadata.getAssociatedPackageNames(0)).isEqualTo("aa")
-//         assertThat(newEntityMetadata.getAssociatedPackageNames(1)).isEqualTo("bb")
-//     }
+        val newEntityMetadata = oldEntityMetadata.update(instantUpdated, associatedPackageNames)
+        assertThat(newEntityMetadata.updated).isEqualTo(instantUpdated.toProtoTimestamp())
+        assertThat(newEntityMetadata.associatedPackageNamesCount).isEqualTo(2)
+        assertThat(newEntityMetadata.getAssociatedPackageNames(0)).isEqualTo("aa")
+        assertThat(newEntityMetadata.getAssociatedPackageNames(1)).isEqualTo("bb")
+    }
 
-//     @Test
-//     fun testEntityMetadataUpdateSingleString() {
-//         val oldEntityMetadata = EntityMetadata("ID", "single_string", Instant.ofEpochMilli(999000), Instant.ofEpochMilli(1000000))
+    @Test
+    fun testEntityMetadataUpdateSingleString() {
+        val oldEntityMetadata = EntityMetadata("ID", "single_string", Instant.ofEpochMilli(999000), Instant.ofEpochMilli(1000000))
 
-//         val instantUpdated = Instant.ofEpochMilli(1100000)
-//         val updatedString = "updated_single_string"
+        val instantUpdated = Instant.ofEpochMilli(1100000)
+        val updatedString = "updated_single_string"
 
-//         val newEntityMetadata = oldEntityMetadata.update(instantUpdated, updatedString)
-//         assertThat(newEntityMetadata.associatedPackageNamesCount).isEqualTo(1)
-//         assertThat(newEntityMetadata.updated).isEqualTo(instantUpdated.toProtoTimestamp())
-//         assertThat(newEntityMetadata.getAssociatedPackageNames(0)).isEqualTo(updatedString)
-//     }
+        val newEntityMetadata = oldEntityMetadata.update(instantUpdated, updatedString)
+        assertThat(newEntityMetadata.associatedPackageNamesCount).isEqualTo(1)
+        assertThat(newEntityMetadata.updated).isEqualTo(instantUpdated.toProtoTimestamp())
+        assertThat(newEntityMetadata.getAssociatedPackageNames(0)).isEqualTo(updatedString)
+    }
 
-//     @Test
-//     fun testWrappedEntity() {
-//         val entityMetadata = EntityMetadata("foobar", "a", Instant.ofEpochMilli(999000), Instant.ofEpochMilli(1000000))
-//         val foobar = Foobar("foobar")
-//         val wrappedEntity = WrappedEntity(entityMetadata, foobar)
-//         assertThat(wrappedEntity.entity.name).isEqualTo("foobar")
-//     }
-// }
\ No newline at end of file
+    @Test
+    fun testWrappedEntity() {
+        val entityMetadata = EntityMetadata("foobar", "a", Instant.ofEpochMilli(999000), Instant.ofEpochMilli(1000000))
+        val foobar = Foobar("foobar")
+        val wrappedEntity = WrappedEntity(entityMetadata, foobar)
+        assertThat(wrappedEntity.entity.name).isEqualTo("foobar")
+    }
+}
\ No newline at end of file
diff --git a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/DefaultPolicyConformanceCheckTest.kt b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/DefaultPolicyConformanceCheckTest.kt
index bdc6a8b0..c54747ec 100644
--- a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/DefaultPolicyConformanceCheckTest.kt
+++ b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/DefaultPolicyConformanceCheckTest.kt
@@ -14,84 +14,84 @@
  * limitations under the License.
  */
 
-// package com.android.libraries.pcc.chronicle.test
+package com.android.libraries.pcc.chronicle.test
 
-// import androidx.test.ext.junit.runners.AndroidJUnit4
-// import com.android.libraries.pcc.chronicle.api.dataTypeDescriptor
-// import com.android.libraries.pcc.chronicle.api.error.MalformedPolicySet
-// import com.android.libraries.pcc.chronicle.api.policy.builder.policy
-// import com.android.libraries.pcc.chronicle.test.data.Foobar
-// import com.android.libraries.pcc.chronicle.api.policy.StorageMedium
-// import com.android.libraries.pcc.chronicle.api.policy.DefaultPolicyConformanceCheck
-// import com.android.libraries.pcc.chronicle.api.FieldType
-// import com.android.libraries.pcc.chronicle.api.dataTypeDescriptor
-// import com.google.common.truth.Truth.assertThat
-// import java.time.Duration
-// import kotlin.test.assertFailsWith
-// import org.junit.Test
-// import org.junit.runner.RunWith
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.libraries.pcc.chronicle.api.dataTypeDescriptor
+import com.android.libraries.pcc.chronicle.api.error.MalformedPolicySet
+import com.android.libraries.pcc.chronicle.api.policy.builder.policy
+import com.android.libraries.pcc.chronicle.test.data.Foobar
+import com.android.libraries.pcc.chronicle.api.policy.StorageMedium
+import com.android.libraries.pcc.chronicle.api.policy.DefaultPolicyConformanceCheck
+import com.android.libraries.pcc.chronicle.api.FieldType
+import com.android.libraries.pcc.chronicle.api.dataTypeDescriptor
+import com.google.common.truth.Truth.assertThat
+import java.time.Duration
+import kotlin.test.assertFailsWith
+import org.junit.Test
+import org.junit.runner.RunWith
 
 
-// @RunWith(AndroidJUnit4::class)
-// class DefaultPolicyConformanceCheckTest {
-//     private val check = DefaultPolicyConformanceCheck()
-//     val FOOBAR_DTD = dataTypeDescriptor("Foobar", Foobar::class) {
-//         "name" to FieldType.String
-//     }
+@RunWith(AndroidJUnit4::class)
+class DefaultPolicyConformanceCheckTest {
+    private val check = DefaultPolicyConformanceCheck()
+    val FOOBAR_DTD = dataTypeDescriptor("Foobar", Foobar::class) {
+        "name" to FieldType.String
+    }
 
-//     @Test
-//     fun testIfDescriptionMissing() {
-//         val policies = setOf(
-//             policy("MyFirstPolicy", "TestEgress") {
-//                 // Pretend we forgot a description here.
-//                 target(FOOBAR_DTD, maxAge = Duration.ZERO) { retention(StorageMedium.RAM) }
-//             },
-//             policy("MySecondPolicy", "TestEgress") {
-//                 description = "I didn't forget a description!"
-//                 target(FOOBAR_DTD, maxAge = Duration.ZERO) { retention(StorageMedium.RAM) }
-//             },
-//         )
+    @Test
+    fun testIfDescriptionMissing() {
+        val policies = setOf(
+            policy("MyFirstPolicy", "TestEgress") {
+                // Pretend we forgot a description here.
+                target(FOOBAR_DTD, maxAge = Duration.ZERO) { retention(StorageMedium.RAM) }
+            },
+            policy("MySecondPolicy", "TestEgress") {
+                description = "I didn't forget a description!"
+                target(FOOBAR_DTD, maxAge = Duration.ZERO) { retention(StorageMedium.RAM) }
+            },
+        )
 
-//         val e = assertFailsWith<MalformedPolicySet> { check.checkPoliciesConform(policies) }
-//         assertThat(e).hasMessageThat().contains("Policy: \"MyFirstPolicy\" has an empty description")
-//     }
+        val e = assertFailsWith<MalformedPolicySet> { check.checkPoliciesConform(policies) }
+        assertThat(e).hasMessageThat().contains("Policy: \"MyFirstPolicy\" has an empty description")
+    }
 
-//     @Test
-//     fun testIfRetentionRulesElided() {
-//         val policies = setOf(
-//             policy("MyFirstPolicy", "TestEgress") {
-//             description = "I didn't forget a description!"
-//             target(FOOBAR_DTD, maxAge = Duration.ZERO) {
-//                 // Forgot to put a retention rule here.
-//             }
-//             },
-//             policy("MySecondPolicy", "TestEgress") {
-//             description = "I didn't forget a description!"
-//             target(FOOBAR_DTD, maxAge = Duration.ZERO) { retention(StorageMedium.RAM) }
-//             },
-//         )
+    @Test
+    fun testIfRetentionRulesElided() {
+        val policies = setOf(
+            policy("MyFirstPolicy", "TestEgress") {
+            description = "I didn't forget a description!"
+            target(FOOBAR_DTD, maxAge = Duration.ZERO) {
+                // Forgot to put a retention rule here.
+            }
+            },
+            policy("MySecondPolicy", "TestEgress") {
+            description = "I didn't forget a description!"
+            target(FOOBAR_DTD, maxAge = Duration.ZERO) { retention(StorageMedium.RAM) }
+            },
+        )
 
-//         val e = assertFailsWith<MalformedPolicySet> { check.checkPoliciesConform(policies) }
-//         assertThat(e)
-//         .hasMessageThat()
-//         .contains(
-//             "Malformed policies found: Target \"Foobar\" from policy: \"MyFirstPolicy\" does not specify any retention rules"
-//         )
-//     }
+        val e = assertFailsWith<MalformedPolicySet> { check.checkPoliciesConform(policies) }
+        assertThat(e)
+        .hasMessageThat()
+        .contains(
+            "Malformed policies found: Target \"Foobar\" from policy: \"MyFirstPolicy\" does not specify any retention rules"
+        )
+    }
 
-//     @Test
-//     fun testWhenPoliciesConform() {
-//         val policies = setOf(
-//             policy("MyFirstPolicy", "TestEgress") {
-//                 description = "I didn't forget a description!"
-//                 target(FOOBAR_DTD, maxAge = Duration.ZERO) { retention(StorageMedium.RAM) }
-//             },
-//             policy("MySecondPolicy", "TestEgress") {
-//                 description = "I didn't forget a description!"
-//                 target(FOOBAR_DTD, maxAge = Duration.ZERO) { retention(StorageMedium.RAM) }
-//             },
-//         )
+    @Test
+    fun testWhenPoliciesConform() {
+        val policies = setOf(
+            policy("MyFirstPolicy", "TestEgress") {
+                description = "I didn't forget a description!"
+                target(FOOBAR_DTD, maxAge = Duration.ZERO) { retention(StorageMedium.RAM) }
+            },
+            policy("MySecondPolicy", "TestEgress") {
+                description = "I didn't forget a description!"
+                target(FOOBAR_DTD, maxAge = Duration.ZERO) { retention(StorageMedium.RAM) }
+            },
+        )
 
-//         check.checkPoliciesConform(policies)
-//     }
-// }
+        check.checkPoliciesConform(policies)
+    }
+}
diff --git a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/data/TestData.kt b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/data/TestData.kt
index b9db7111..ea22ca2b 100644
--- a/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/data/TestData.kt
+++ b/tests/chronicletests/src/com/android/libraries/pcc/chronicle/test/data/TestData.kt
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-// package com.android.libraries.pcc.chronicle.test.data
+package com.android.libraries.pcc.chronicle.test.data
 
-// /** Placeholder DataType for testing Chronicle. */
+/** Placeholder DataType for testing Chronicle. */
 
-// data class Foobar(val name: String)
+data class Foobar(val name: String)
 
-// data class SimpleData(val a: Int, val b: Int)
+data class SimpleData(val a: Int, val b: Int)
 
-// data class NestedPerson(val name: String, val age: Int, val pets: NestedPet)
+data class NestedPerson(val name: String, val age: Int, val pets: NestedPet)
 
-// data class NestedPet(val breed: String)
\ No newline at end of file
+data class NestedPet(val breed: String)
\ No newline at end of file