[SP26.1] Add assert function for parceling NetworkStats

In ParcelUtils there are methods that help to verify parceling
correctness. However, they can only be applied to objects which
implement equals.

For NetworkStats, equals are not overrided due to performace
might be impacted if everyone use it. Hence specfic function
to verify parceling correectness is needed.

Test: atest NetworkStatsApiTest NetworkStackTests
Bug: 150644692
Change-Id: I48aa73117bc7db981ffaef5365f96e46d431bd6e
Merged-In: I48aa73117bc7db981ffaef5365f96e46d431bd6e

2 files changed, 39 insertions, 13 deletions

diff --git a/tests/lib/src/com/android/testutils/NetworkStatsUtils.kt b/tests/lib/src/com/android/testutils/NetworkStatsUtils.kt
index 51e9e4d..8324b25 100644
--- a/tests/lib/src/com/android/testutils/NetworkStatsUtils.kt
+++ b/tests/lib/src/com/android/testutils/NetworkStatsUtils.kt
@@ -29,16 +29,24 @@ fun orderInsensitiveEquals(
     if (compareTime && leftStats.getElapsedRealtime() != rightStats.getElapsedRealtime()) {
         return false
     }
-    if (leftStats.size() != rightStats.size()) return false
+
+    // While operations such as add/subtract will preserve empty entries. This will make
+    // the result be hard to verify during test. Remove them before comparing since they
+    // are not really affect correctness.
+    // TODO (b/152827872): Remove empty entries after addition/subtraction.
+    val leftTrimmedEmpty = leftStats.removeEmptyEntries()
+    val rightTrimmedEmpty = rightStats.removeEmptyEntries()
+
+    if (leftTrimmedEmpty.size() != rightTrimmedEmpty.size()) return false
     val left = NetworkStats.Entry()
     val right = NetworkStats.Entry()
     // Order insensitive compare.
-    for (i in 0 until leftStats.size()) {
-        leftStats.getValues(i, left)
-        val j: Int = rightStats.findIndexHinted(left.iface, left.uid, left.set, left.tag,
+    for (i in 0 until leftTrimmedEmpty.size()) {
+        leftTrimmedEmpty.getValues(i, left)
+        val j: Int = rightTrimmedEmpty.findIndexHinted(left.iface, left.uid, left.set, left.tag,
                 left.metered, left.roaming, left.defaultNetwork, i)
         if (j == -1) return false
-        rightStats.getValues(j, right)
+        rightTrimmedEmpty.getValues(j, right)
         if (left != right) return false
     }
     return true
@@ -58,5 +66,13 @@ fun assertNetworkStatsEquals(
     compareTime: Boolean = false
 ) {
     assertTrue(orderInsensitiveEquals(expected, actual, compareTime),
-            "expected: " + expected + "but was: " + actual)
+            "expected: " + expected + " but was: " + actual)
+}
+
+/**
+ * Assert that after being parceled then unparceled, {@link NetworkStats} is equal to the original
+ * object.
+ */
+fun assertParcelingIsLossless(stats: NetworkStats) {
+    assertParcelingIsLossless(stats, { a, b -> orderInsensitiveEquals(a, b) })
 }
diff --git a/tests/lib/src/com/android/testutils/ParcelUtils.kt b/tests/lib/src/com/android/testutils/ParcelUtils.kt
index 9cbd053..5784f7c 100644
--- a/tests/lib/src/com/android/testutils/ParcelUtils.kt
+++ b/tests/lib/src/com/android/testutils/ParcelUtils.kt
@@ -18,13 +18,13 @@ package com.android.testutils
 
 import android.os.Parcel
 import android.os.Parcelable
-import kotlin.test.assertEquals
+import kotlin.test.assertTrue
 import kotlin.test.fail
 
 /**
  * Return a new instance of `T` after being parceled then unparceled.
  */
-fun <T: Parcelable> parcelingRoundTrip(source: T): T {
+fun <T : Parcelable> parcelingRoundTrip(source: T): T {
     val creator: Parcelable.Creator<T>
     try {
         creator = source.javaClass.getField("CREATOR").get(null) as Parcelable.Creator<T>
@@ -46,13 +46,23 @@ fun <T: Parcelable> parcelingRoundTrip(source: T): T {
 
 /**
  * Assert that after being parceled then unparceled, `source` is equal to the original
- * object.
+ * object. If a customized equals function is provided, uses the provided one.
  */
-fun <T: Parcelable> assertParcelingIsLossless(source: T) {
-    assertEquals(source, parcelingRoundTrip(source))
+@JvmOverloads
+fun <T : Parcelable> assertParcelingIsLossless(
+    source: T,
+    equals: (T, T) -> Boolean = { a, b -> a == b }
+) {
+    val actual = parcelingRoundTrip(source)
+    assertTrue(equals(source, actual), "Expected $source, but was $actual")
 }
 
-fun <T: Parcelable> assertParcelSane(obj: T, fieldCount: Int) {
+@JvmOverloads
+fun <T : Parcelable> assertParcelSane(
+    obj: T,
+    fieldCount: Int,
+    equals: (T, T) -> Boolean = { a, b -> a == b }
+) {
     assertFieldCountEquals(fieldCount, obj::class.java)
-    assertParcelingIsLossless(obj)
+    assertParcelingIsLossless(obj, equals)
 }