Add tests for unique id in AIDL program info cache

Added unit tests for program info cache of AIDL broadcast radio HAL
client on unique program identifier.

Bug: 273967346
Test: atest com.android.server.broadcastradio
Change-Id: I4253a6fd82555edb3f03e83195baffa55bec439c

2 files changed, 287 insertions, 162 deletions

diff --git a/core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/aidl/ProgramInfoCacheTest.java b/core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/aidl/ProgramInfoCacheTest.java
index 58107ccf25c7..ce27bc177769 100644
--- a/core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/aidl/ProgramInfoCacheTest.java
+++ b/core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/aidl/ProgramInfoCacheTest.java
@@ -33,6 +33,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.junit.MockitoJUnitRunner;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 
@@ -44,6 +45,9 @@ public class ProgramInfoCacheTest {
 
     private static final int TEST_SIGNAL_QUALITY = 90;
 
+    private static final int TEST_MAX_NUM_MODIFIED_PER_CHUNK = 2;
+    private static final int TEST_MAX_NUM_REMOVED_PER_CHUNK = 2;
+
     private static final ProgramSelector.Identifier TEST_FM_FREQUENCY_ID =
             new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY,
                     /* value= */ 88_500);
@@ -86,15 +90,27 @@ public class ProgramInfoCacheTest {
     private static final ProgramSelector.Identifier TEST_DAB_FREQUENCY_ID =
             new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_FREQUENCY,
                     /* value= */ 220_352);
+    private static final ProgramSelector.Identifier TEST_DAB_FREQUENCY_ID_ALTERNATIVE =
+            new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_FREQUENCY,
+                    /* value= */ 220_064);
     private static final ProgramSelector TEST_DAB_SELECTOR = new ProgramSelector(
             ProgramSelector.PROGRAM_TYPE_DAB, TEST_DAB_DMB_SID_EXT_ID,
             new ProgramSelector.Identifier[]{TEST_DAB_FREQUENCY_ID, TEST_DAB_ENSEMBLE_ID},
             /* vendorIds= */ null);
+    private static final ProgramSelector TEST_DAB_SELECTOR_ALTERNATIVE = new ProgramSelector(
+            ProgramSelector.PROGRAM_TYPE_DAB, TEST_DAB_DMB_SID_EXT_ID,
+            new ProgramSelector.Identifier[]{TEST_DAB_FREQUENCY_ID_ALTERNATIVE,
+                    TEST_DAB_ENSEMBLE_ID}, /* vendorIds= */ null);
     private static final UniqueProgramIdentifier TEST_DAB_UNIQUE_ID = new UniqueProgramIdentifier(
             TEST_DAB_SELECTOR);
-    private static final RadioManager.ProgramInfo TEST_DAB_INFO = AidlTestUtils.makeProgramInfo(
-            TEST_DAB_SELECTOR, TEST_DAB_DMB_SID_EXT_ID, TEST_DAB_FREQUENCY_ID,
-            TEST_SIGNAL_QUALITY);
+    private static final UniqueProgramIdentifier TEST_DAB_UNIQUE_ID_ALTERNATIVE =
+            new UniqueProgramIdentifier(TEST_DAB_SELECTOR_ALTERNATIVE);
+    private static final RadioManager.ProgramInfo TEST_DAB_INFO =
+            AidlTestUtils.makeProgramInfo(TEST_DAB_SELECTOR, TEST_DAB_DMB_SID_EXT_ID,
+                    TEST_DAB_FREQUENCY_ID, TEST_SIGNAL_QUALITY);
+    private static final RadioManager.ProgramInfo TEST_DAB_INFO_ALTERNATIVE =
+            AidlTestUtils.makeProgramInfo(TEST_DAB_SELECTOR_ALTERNATIVE, TEST_DAB_DMB_SID_EXT_ID,
+                    TEST_DAB_FREQUENCY_ID_ALTERNATIVE, TEST_SIGNAL_QUALITY);
 
     private static final ProgramSelector.Identifier TEST_VENDOR_ID =
             new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_VENDOR_START,
@@ -104,8 +120,8 @@ public class ProgramInfoCacheTest {
                     TEST_VENDOR_ID), TEST_VENDOR_ID, TEST_VENDOR_ID, TEST_SIGNAL_QUALITY);
 
     private static final ProgramInfoCache FULL_PROGRAM_INFO_CACHE = new ProgramInfoCache(
-            /* filter= */ null, /* complete= */ true,
-            TEST_FM_INFO, TEST_AM_INFO, TEST_RDS_INFO, TEST_DAB_INFO, TEST_VENDOR_INFO);
+            /* filter= */ null, /* complete= */ true, TEST_FM_INFO, TEST_AM_INFO, TEST_RDS_INFO,
+            TEST_DAB_INFO, TEST_DAB_INFO_ALTERNATIVE, TEST_VENDOR_INFO);
 
     @Rule
     public final Expect expect = Expect.create();
@@ -197,7 +213,7 @@ public class ProgramInfoCacheTest {
         expect.withMessage("Program cache filtered by null filter")
                 .that(cache.toProgramInfoList())
                 .containsExactly(TEST_FM_INFO, TEST_AM_INFO, TEST_RDS_INFO, TEST_DAB_INFO,
-                        TEST_VENDOR_INFO);
+                        TEST_DAB_INFO_ALTERNATIVE, TEST_VENDOR_INFO);
     }
 
     @Test
@@ -211,21 +227,21 @@ public class ProgramInfoCacheTest {
         expect.withMessage("Program cache filtered by empty filter")
                 .that(cache.toProgramInfoList())
                 .containsExactly(TEST_FM_INFO, TEST_AM_INFO, TEST_RDS_INFO, TEST_DAB_INFO,
-                        TEST_VENDOR_INFO);
+                        TEST_DAB_INFO_ALTERNATIVE, TEST_VENDOR_INFO);
     }
 
     @Test
     public void filterAndUpdateFromInternal_withFilterByIdentifierType() {
         ProgramInfoCache cache = new ProgramInfoCache(
                 new ProgramList.Filter(Set.of(ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY,
-                        ProgramSelector.IDENTIFIER_TYPE_RDS_PI), new ArraySet<>(),
+                        ProgramSelector.IDENTIFIER_TYPE_DAB_DMB_SID_EXT), new ArraySet<>(),
                         /* includeCategories= */ true, /* excludeModifications= */ false));
 
         cache.filterAndUpdateFromInternal(FULL_PROGRAM_INFO_CACHE, /* purge= */ false);
 
         expect.withMessage("Program cache filtered by identifier type")
-                .that(cache.toProgramInfoList())
-                .containsExactly(TEST_FM_INFO, TEST_AM_INFO, TEST_RDS_INFO);
+                .that(cache.toProgramInfoList()).containsExactly(TEST_FM_INFO, TEST_AM_INFO,
+                        TEST_DAB_INFO, TEST_DAB_INFO_ALTERNATIVE);
     }
 
     @Test
@@ -233,20 +249,60 @@ public class ProgramInfoCacheTest {
         ProgramInfoCache cache = new ProgramInfoCache(new ProgramList.Filter(
                 new ArraySet<>(), Set.of(TEST_FM_FREQUENCY_ID, TEST_DAB_DMB_SID_EXT_ID),
                 /* includeCategories= */ true, /* excludeModifications= */ false));
-        int maxNumModifiedPerChunk = 2;
-        int maxNumRemovedPerChunk = 2;
 
         List<ProgramList.Chunk> programListChunks = cache.filterAndUpdateFromInternal(
-                FULL_PROGRAM_INFO_CACHE, /* purge= */ true, maxNumModifiedPerChunk,
-                maxNumRemovedPerChunk);
+                FULL_PROGRAM_INFO_CACHE, /* purge= */ false, TEST_MAX_NUM_MODIFIED_PER_CHUNK,
+                TEST_MAX_NUM_REMOVED_PER_CHUNK);
 
         expect.withMessage("Program cache filtered by identifier")
-                .that(cache.toProgramInfoList()).containsExactly(TEST_FM_INFO, TEST_DAB_INFO);
+                .that(cache.toProgramInfoList()).containsExactly(TEST_FM_INFO, TEST_DAB_INFO,
+                        TEST_DAB_INFO_ALTERNATIVE);
         verifyChunkListPurge(programListChunks, /* purge= */ true);
-        verifyChunkListComplete(programListChunks, FULL_PROGRAM_INFO_CACHE.isComplete());
+        verifyChunkListComplete(programListChunks, cache.isComplete());
+        verifyChunkListModified(programListChunks, TEST_MAX_NUM_MODIFIED_PER_CHUNK, TEST_FM_INFO,
+                TEST_DAB_INFO, TEST_DAB_INFO_ALTERNATIVE);
+        verifyChunkListRemoved(programListChunks, TEST_MAX_NUM_REMOVED_PER_CHUNK);
+    }
+
+    @Test
+    public void filterAndUpdateFromInternal_withPurging() {
+        ProgramInfoCache cache = new ProgramInfoCache(new ProgramList.Filter(new ArraySet<>(),
+                new ArraySet<>(), /* includeCategories= */ true, /* excludeModifications= */ false),
+                /* complete= */ true, TEST_RDS_INFO, TEST_DAB_INFO);
+        ProgramInfoCache otherCache = new ProgramInfoCache(/* filter= */ null, /* complete= */ true,
+                TEST_FM_INFO, TEST_RDS_INFO, TEST_DAB_INFO_ALTERNATIVE);
+
+        List<ProgramList.Chunk> programListChunks = cache.filterAndUpdateFromInternal(otherCache,
+                /* purge= */ true, TEST_MAX_NUM_MODIFIED_PER_CHUNK, TEST_MAX_NUM_REMOVED_PER_CHUNK);
+
+        expect.withMessage("Program cache filtered with purging").that(cache.toProgramInfoList())
+                .containsExactly(TEST_FM_INFO, TEST_RDS_INFO, TEST_DAB_INFO_ALTERNATIVE);
+        verifyChunkListPurge(programListChunks, /* purge= */ true);
+        verifyChunkListModified(programListChunks, TEST_MAX_NUM_MODIFIED_PER_CHUNK, TEST_FM_INFO,
+                TEST_RDS_INFO, TEST_DAB_INFO_ALTERNATIVE);
+        verifyChunkListRemoved(programListChunks, TEST_MAX_NUM_REMOVED_PER_CHUNK);
+    }
+
+    @Test
+    public void filterAndUpdateFromInternal_withoutPurging() {
+        ProgramInfoCache cache = new ProgramInfoCache(new ProgramList.Filter(new ArraySet<>(),
+                new ArraySet<>(), /* includeCategories= */ true, /* excludeModifications= */ false),
+                /* complete= */ true, TEST_RDS_INFO, TEST_DAB_INFO);
+        ProgramInfoCache otherCache = new ProgramInfoCache(/* filter= */ null, /* complete= */ true,
+                TEST_FM_INFO, TEST_RDS_INFO, TEST_DAB_INFO_ALTERNATIVE);
+        int maxNumModifiedPerChunk = 1;
+
+        List<ProgramList.Chunk> programListChunks = cache.filterAndUpdateFromInternal(otherCache,
+                /* purge= */ false, maxNumModifiedPerChunk, TEST_MAX_NUM_REMOVED_PER_CHUNK);
+
+        expect.withMessage("Program cache filtered without puring").that(cache.toProgramInfoList())
+                .containsExactly(TEST_FM_INFO, TEST_RDS_INFO, TEST_DAB_INFO_ALTERNATIVE);
+        verifyChunkListPurge(programListChunks, /* purge= */ false);
+        verifyChunkListComplete(programListChunks, cache.isComplete());
         verifyChunkListModified(programListChunks, maxNumModifiedPerChunk, TEST_FM_INFO,
-                TEST_DAB_INFO);
-        verifyChunkListRemoved(programListChunks, maxNumRemovedPerChunk);
+                TEST_DAB_INFO_ALTERNATIVE);
+        verifyChunkListRemoved(programListChunks, TEST_MAX_NUM_REMOVED_PER_CHUNK,
+                TEST_DAB_UNIQUE_ID);
     }
 
     @Test
@@ -255,20 +311,19 @@ public class ProgramInfoCacheTest {
                 new ArraySet<>(), /* includeCategories= */ false,
                 /* excludeModifications= */ false));
         int maxNumModifiedPerChunk = 3;
-        int maxNumRemovedPerChunk = 2;
 
         List<ProgramList.Chunk> programListChunks = cache.filterAndUpdateFromInternal(
                 FULL_PROGRAM_INFO_CACHE, /* purge= */ false, maxNumModifiedPerChunk,
-                maxNumRemovedPerChunk);
+                TEST_MAX_NUM_REMOVED_PER_CHUNK);
 
         expect.withMessage("Program cache filtered by excluding categories")
-                .that(cache.toProgramInfoList())
-                .containsExactly(TEST_FM_INFO, TEST_AM_INFO, TEST_RDS_INFO, TEST_DAB_INFO);
+                .that(cache.toProgramInfoList()).containsExactly(TEST_FM_INFO, TEST_AM_INFO,
+                        TEST_RDS_INFO, TEST_DAB_INFO, TEST_DAB_INFO_ALTERNATIVE);
         verifyChunkListPurge(programListChunks, /* purge= */ true);
-        verifyChunkListComplete(programListChunks, FULL_PROGRAM_INFO_CACHE.isComplete());
+        verifyChunkListComplete(programListChunks, cache.isComplete());
         verifyChunkListModified(programListChunks, maxNumModifiedPerChunk, TEST_FM_INFO,
-                TEST_AM_INFO, TEST_RDS_INFO, TEST_DAB_INFO);
-        verifyChunkListRemoved(programListChunks, maxNumRemovedPerChunk);
+                TEST_AM_INFO, TEST_RDS_INFO, TEST_DAB_INFO, TEST_DAB_INFO_ALTERNATIVE);
+        verifyChunkListRemoved(programListChunks, TEST_MAX_NUM_REMOVED_PER_CHUNK);
     }
 
     @Test
@@ -279,21 +334,21 @@ public class ProgramInfoCacheTest {
         ProgramInfoCache cache = new ProgramInfoCache(filterExcludingModifications,
                 /* complete= */ true, TEST_FM_INFO, TEST_RDS_INFO, TEST_AM_INFO, TEST_DAB_INFO);
         ProgramInfoCache halCache = new ProgramInfoCache(/* filter= */ null, /* complete= */ false,
-                TEST_FM_INFO_MODIFIED, TEST_VENDOR_INFO);
-        int maxNumModifiedPerChunk = 2;
-        int maxNumRemovedPerChunk = 2;
+                TEST_FM_INFO_MODIFIED, TEST_DAB_INFO_ALTERNATIVE, TEST_VENDOR_INFO);
 
         List<ProgramList.Chunk> programListChunks = cache.filterAndUpdateFromInternal(halCache,
-                /* purge= */ false, maxNumModifiedPerChunk, maxNumRemovedPerChunk);
+                /* purge= */ false, TEST_MAX_NUM_MODIFIED_PER_CHUNK,
+                TEST_MAX_NUM_REMOVED_PER_CHUNK);
 
         expect.withMessage("Program cache filtered by excluding modifications")
                 .that(cache.toProgramInfoList())
-                .containsExactly(TEST_FM_INFO, TEST_VENDOR_INFO);
+                .containsExactly(TEST_FM_INFO, TEST_DAB_INFO_ALTERNATIVE, TEST_VENDOR_INFO);
         verifyChunkListPurge(programListChunks, /* purge= */ false);
         verifyChunkListComplete(programListChunks, halCache.isComplete());
-        verifyChunkListModified(programListChunks, maxNumModifiedPerChunk, TEST_VENDOR_INFO);
-        verifyChunkListRemoved(programListChunks, maxNumRemovedPerChunk, TEST_RDS_PI_UNIQUE_ID,
-                TEST_AM_UNIQUE_ID, TEST_DAB_UNIQUE_ID);
+        verifyChunkListModified(programListChunks, TEST_MAX_NUM_MODIFIED_PER_CHUNK,
+                TEST_VENDOR_INFO, TEST_DAB_INFO_ALTERNATIVE);
+        verifyChunkListRemoved(programListChunks, TEST_MAX_NUM_REMOVED_PER_CHUNK,
+                TEST_RDS_PI_UNIQUE_ID, TEST_AM_UNIQUE_ID, TEST_DAB_UNIQUE_ID);
     }
 
     @Test
@@ -301,69 +356,88 @@ public class ProgramInfoCacheTest {
         ProgramInfoCache cache = new ProgramInfoCache(new ProgramList.Filter(new ArraySet<>(),
                 new ArraySet<>(), /* includeCategories= */ true,
                 /* excludeModifications= */ false),
-                /* complete= */ true, TEST_FM_INFO, TEST_RDS_INFO);
+                /* complete= */ true, TEST_FM_INFO, TEST_RDS_INFO, TEST_DAB_INFO);
         ProgramInfoCache halCache = new ProgramInfoCache(/* filter= */ null, /* complete= */ false,
-                TEST_FM_INFO_MODIFIED, TEST_DAB_INFO, TEST_VENDOR_INFO);
-        int maxNumModifiedPerChunk = 2;
-        int maxNumRemovedPerChunk = 2;
+                TEST_FM_INFO_MODIFIED, TEST_DAB_INFO_ALTERNATIVE, TEST_VENDOR_INFO);
 
         List<ProgramList.Chunk> programListChunks = cache.filterAndUpdateFromInternal(halCache,
-                /* purge= */ true, maxNumModifiedPerChunk, maxNumRemovedPerChunk);
+                /* purge= */ true, TEST_MAX_NUM_MODIFIED_PER_CHUNK, TEST_MAX_NUM_REMOVED_PER_CHUNK);
 
         expect.withMessage("Purged program cache").that(cache.toProgramInfoList())
-                .containsExactly(TEST_FM_INFO_MODIFIED, TEST_DAB_INFO, TEST_VENDOR_INFO);
+                .containsExactly(TEST_FM_INFO_MODIFIED, TEST_DAB_INFO_ALTERNATIVE,
+                        TEST_VENDOR_INFO);
         verifyChunkListPurge(programListChunks, /* purge= */ true);
         verifyChunkListComplete(programListChunks, halCache.isComplete());
-        verifyChunkListModified(programListChunks, maxNumModifiedPerChunk, TEST_FM_INFO_MODIFIED,
-                TEST_DAB_INFO, TEST_VENDOR_INFO);
-        verifyChunkListRemoved(programListChunks, maxNumRemovedPerChunk);
+        verifyChunkListModified(programListChunks, TEST_MAX_NUM_MODIFIED_PER_CHUNK,
+                TEST_FM_INFO_MODIFIED, TEST_DAB_INFO_ALTERNATIVE, TEST_VENDOR_INFO);
+        verifyChunkListRemoved(programListChunks, TEST_MAX_NUM_REMOVED_PER_CHUNK);
     }
 
     @Test
-    public void filterAndApplyChunkInternal_withPurgingIncompleteChunk() throws RemoteException {
+    public void filterAndApplyChunkInternal_withPurgingAndIncompleteChunk() throws RemoteException {
         ProgramInfoCache cache = new ProgramInfoCache(/* filter= */ null,
-                /* complete= */ false, TEST_FM_INFO, TEST_DAB_INFO);
+                /* complete= */ false, TEST_FM_INFO, TEST_RDS_INFO, TEST_DAB_INFO);
         ProgramListChunk halChunk = AidlTestUtils.makeHalChunk(/* purge= */ true,
-                /* complete= */ false, List.of(TEST_FM_INFO_MODIFIED, TEST_RDS_INFO,
-                        TEST_VENDOR_INFO), List.of(TEST_DAB_DMB_SID_EXT_ID));
-        int maxNumModifiedPerChunk = 2;
-        int maxNumRemovedPerChunk = 2;
+                /* complete= */ false, List.of(TEST_FM_INFO_MODIFIED,
+                        TEST_DAB_INFO_ALTERNATIVE, TEST_VENDOR_INFO), new ArrayList<>());
 
         List<ProgramList.Chunk> programListChunks = cache.filterAndApplyChunkInternal(halChunk,
-                maxNumModifiedPerChunk, maxNumRemovedPerChunk);
+                TEST_MAX_NUM_MODIFIED_PER_CHUNK, TEST_MAX_NUM_REMOVED_PER_CHUNK);
 
-        expect.withMessage("Program cache applied with non-purging and complete chunk")
-                .that(cache.toProgramInfoList())
-                .containsExactly(TEST_FM_INFO_MODIFIED, TEST_RDS_INFO, TEST_VENDOR_INFO);
+        expect.withMessage("Program cache applied with purge-enabled and complete chunk")
+                .that(cache.toProgramInfoList()).containsExactly(TEST_FM_INFO_MODIFIED,
+                        TEST_DAB_INFO_ALTERNATIVE, TEST_VENDOR_INFO);
         verifyChunkListPurge(programListChunks, /* purge= */ true);
         verifyChunkListComplete(programListChunks, /* complete= */ false);
-        verifyChunkListModified(programListChunks, maxNumModifiedPerChunk, TEST_FM_INFO_MODIFIED,
-                TEST_RDS_INFO, TEST_VENDOR_INFO);
-        verifyChunkListRemoved(programListChunks, maxNumRemovedPerChunk);
+        verifyChunkListModified(programListChunks, TEST_MAX_NUM_MODIFIED_PER_CHUNK,
+                TEST_FM_INFO_MODIFIED, TEST_DAB_INFO_ALTERNATIVE, TEST_VENDOR_INFO);
+        verifyChunkListRemoved(programListChunks, TEST_MAX_NUM_REMOVED_PER_CHUNK);
     }
 
     @Test
-    public void filterAndApplyChunk_withNonPurgingCompleteChunk() throws RemoteException {
-        ProgramInfoCache cache = new ProgramInfoCache(/* filter= */ null,
-                /* complete= */ false, TEST_FM_INFO, TEST_RDS_INFO, TEST_AM_INFO, TEST_DAB_INFO);
+    public void filterAndApplyChunk_withNonPurgingAndIncompleteChunk() throws RemoteException {
+        ProgramInfoCache cache = new ProgramInfoCache(/* filter= */ null, /* complete= */ false,
+                TEST_FM_INFO, TEST_RDS_INFO, TEST_AM_INFO, TEST_DAB_INFO);
+        ProgramListChunk halChunk = AidlTestUtils.makeHalChunk(/* purge= */ false,
+                /* complete= */ false, List.of(TEST_FM_INFO_MODIFIED, TEST_DAB_INFO_ALTERNATIVE,
+                        TEST_VENDOR_INFO), List.of(TEST_RDS_PI_ID, TEST_AM_FREQUENCY_ID));
+
+        List<ProgramList.Chunk> programListChunks = cache.filterAndApplyChunkInternal(halChunk,
+                TEST_MAX_NUM_MODIFIED_PER_CHUNK, TEST_MAX_NUM_REMOVED_PER_CHUNK);
+
+        expect.withMessage("Program cache applied with non-purging and incomplete chunk")
+                .that(cache.toProgramInfoList()).containsExactly(TEST_DAB_INFO,
+                        TEST_DAB_INFO_ALTERNATIVE, TEST_FM_INFO_MODIFIED, TEST_VENDOR_INFO);
+        verifyChunkListPurge(programListChunks, /* purge= */ false);
+        verifyChunkListComplete(programListChunks, /* complete= */ false);
+        verifyChunkListModified(programListChunks, TEST_MAX_NUM_MODIFIED_PER_CHUNK,
+                TEST_FM_INFO_MODIFIED, TEST_DAB_INFO_ALTERNATIVE, TEST_VENDOR_INFO);
+        verifyChunkListRemoved(programListChunks, TEST_MAX_NUM_REMOVED_PER_CHUNK,
+                TEST_RDS_PI_UNIQUE_ID, TEST_AM_UNIQUE_ID);
+    }
+
+    @Test
+    public void filterAndApplyChunk_withNonPurgingAndCompleteChunk() throws RemoteException {
+        ProgramInfoCache cache = new ProgramInfoCache(/* filter= */ null, /* complete= */ false,
+                TEST_FM_INFO, TEST_RDS_INFO, TEST_AM_INFO, TEST_DAB_INFO,
+                TEST_DAB_INFO_ALTERNATIVE);
         ProgramListChunk halChunk = AidlTestUtils.makeHalChunk(/* purge= */ false,
                 /* complete= */ true, List.of(TEST_FM_INFO_MODIFIED, TEST_VENDOR_INFO),
                 List.of(TEST_RDS_PI_ID, TEST_AM_FREQUENCY_ID, TEST_DAB_DMB_SID_EXT_ID));
-        int maxNumModifiedPerChunk = 2;
-        int maxNumRemovedPerChunk = 2;
 
         List<ProgramList.Chunk> programListChunks = cache.filterAndApplyChunkInternal(halChunk,
-                maxNumModifiedPerChunk, maxNumRemovedPerChunk);
+                TEST_MAX_NUM_MODIFIED_PER_CHUNK, TEST_MAX_NUM_REMOVED_PER_CHUNK);
 
-        expect.withMessage("Program cache applied with purge-enabled complete chunk")
+        expect.withMessage("Program cache applied with non-purging and complete chunk")
                 .that(cache.toProgramInfoList())
                 .containsExactly(TEST_FM_INFO_MODIFIED, TEST_VENDOR_INFO);
         verifyChunkListPurge(programListChunks, /* purge= */ false);
         verifyChunkListComplete(programListChunks, /* complete= */ true);
-        verifyChunkListModified(programListChunks, maxNumModifiedPerChunk, TEST_FM_INFO_MODIFIED,
-                TEST_VENDOR_INFO);
-        verifyChunkListRemoved(programListChunks, maxNumRemovedPerChunk, TEST_RDS_PI_UNIQUE_ID,
-                TEST_AM_UNIQUE_ID, TEST_DAB_UNIQUE_ID);
+        verifyChunkListModified(programListChunks, TEST_MAX_NUM_MODIFIED_PER_CHUNK,
+                TEST_FM_INFO_MODIFIED, TEST_VENDOR_INFO);
+        verifyChunkListRemoved(programListChunks, TEST_MAX_NUM_REMOVED_PER_CHUNK,
+                TEST_RDS_PI_UNIQUE_ID, TEST_AM_UNIQUE_ID, TEST_DAB_UNIQUE_ID,
+                TEST_DAB_UNIQUE_ID_ALTERNATIVE);
     }
 
     private void verifyChunkListPurge(List<ProgramList.Chunk> chunks, boolean purge) {
diff --git a/core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/aidl/TunerSessionTest.java b/core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/aidl/TunerSessionTest.java
index a64e2230ce4b..a1952282dd0b 100644
--- a/core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/aidl/TunerSessionTest.java
+++ b/core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/aidl/TunerSessionTest.java
@@ -18,8 +18,6 @@ package com.android.server.broadcastradio.aidl;
 
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn;
 
-import static com.google.common.truth.Truth.assertWithMessage;
-
 import static org.junit.Assert.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyBoolean;
@@ -60,13 +58,18 @@ import com.android.dx.mockito.inline.extended.StaticMockitoSessionBuilder;
 import com.android.server.broadcastradio.ExtendedRadioMockitoTestCase;
 import com.android.server.broadcastradio.RadioServiceUserController;
 
+import com.google.common.truth.Expect;
+
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.verification.VerificationWithTimeout;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -95,13 +98,6 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
     private static final ProgramSelector.Identifier TEST_FM_FREQUENCY_ID =
             new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY,
                     /* value= */ 88_500);
-    private static final ProgramSelector.Identifier TEST_RDS_PI_ID =
-            new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_RDS_PI,
-                    /* value= */ 15_019);
-
-    private static final UniqueProgramIdentifier TEST_RDS_PI_UNIQUE_ID =
-            new UniqueProgramIdentifier(TEST_RDS_PI_ID);
-
     private static final RadioManager.ProgramInfo TEST_FM_INFO = AidlTestUtils.makeProgramInfo(
             AidlTestUtils.makeProgramSelector(ProgramSelector.PROGRAM_TYPE_FM,
                     TEST_FM_FREQUENCY_ID), TEST_FM_FREQUENCY_ID, TEST_FM_FREQUENCY_ID,
@@ -110,11 +106,37 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             AidlTestUtils.makeProgramInfo(AidlTestUtils.makeProgramSelector(
                     ProgramSelector.PROGRAM_TYPE_FM, TEST_FM_FREQUENCY_ID), TEST_FM_FREQUENCY_ID,
                     TEST_FM_FREQUENCY_ID, /* signalQuality= */ 100);
-    private static final RadioManager.ProgramInfo TEST_RDS_INFO = AidlTestUtils.makeProgramInfo(
-            AidlTestUtils.makeProgramSelector(ProgramSelector.PROGRAM_TYPE_FM, TEST_RDS_PI_ID),
-            TEST_RDS_PI_ID, new ProgramSelector.Identifier(
-                    ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY, /* value= */ 89_500),
-            SIGNAL_QUALITY);
+
+    private static final ProgramSelector.Identifier TEST_DAB_FREQUENCY_ID =
+            new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_FREQUENCY,
+                    /* value= */ 220_352);
+    private static final ProgramSelector.Identifier TEST_DAB_FREQUENCY_ID_ALT =
+            new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_FREQUENCY,
+                    /* value= */ 220_064);
+    private static final ProgramSelector.Identifier TEST_DAB_SID_EXT_ID =
+            new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_DMB_SID_EXT,
+                    /* value= */ 0xA000000111L);
+    private static final ProgramSelector.Identifier TEST_DAB_ENSEMBLE_ID =
+            new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_ENSEMBLE,
+                    /* value= */ 0x1001);
+    private static final ProgramSelector TEST_DAB_SELECTOR = new ProgramSelector(
+            ProgramSelector.PROGRAM_TYPE_DAB, TEST_DAB_SID_EXT_ID,
+            new ProgramSelector.Identifier[]{TEST_DAB_FREQUENCY_ID, TEST_DAB_ENSEMBLE_ID},
+            /* vendorIds= */ null);
+    private static final ProgramSelector TEST_DAB_SELECTOR_ALT = new ProgramSelector(
+            ProgramSelector.PROGRAM_TYPE_DAB, TEST_DAB_SID_EXT_ID,
+            new ProgramSelector.Identifier[]{TEST_DAB_FREQUENCY_ID_ALT, TEST_DAB_ENSEMBLE_ID},
+            /* vendorIds= */ null);
+    private static final UniqueProgramIdentifier TEST_DAB_UNIQUE_ID = new UniqueProgramIdentifier(
+            TEST_DAB_SELECTOR);
+    private static final UniqueProgramIdentifier TEST_DAB_UNIQUE_ID_ALT =
+            new UniqueProgramIdentifier(TEST_DAB_SELECTOR_ALT);
+    private static final RadioManager.ProgramInfo TEST_DAB_INFO =
+            AidlTestUtils.makeProgramInfo(TEST_DAB_SELECTOR, TEST_DAB_SID_EXT_ID,
+                    TEST_DAB_FREQUENCY_ID, SIGNAL_QUALITY);
+    private static final RadioManager.ProgramInfo TEST_DAB_INFO_ALT =
+            AidlTestUtils.makeProgramInfo(TEST_DAB_SELECTOR_ALT, TEST_DAB_SID_EXT_ID,
+                    TEST_DAB_FREQUENCY_ID_ALT, SIGNAL_QUALITY);
 
     // Mocks
     @Mock
@@ -133,6 +155,9 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
 
     private TunerSession[] mTunerSessions;
 
+    @Rule
+    public final Expect expect = Expect.create();
+
     @Override
     protected void initializeSession(StaticMockitoSessionBuilder builder) {
         builder.spyStatic(RadioServiceUserController.class).spyStatic(CompatChanges.class)
@@ -229,7 +254,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         openAidlClients(numSessions);
 
         for (int index = 0; index < numSessions; index++) {
-            assertWithMessage("Session of index %s close state", index)
+            expect.withMessage("Session of index %s close state", index)
                     .that(mTunerSessions[index].isClosed()).isFalse();
         }
     }
@@ -261,7 +286,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
 
         RadioManager.BandConfig config = mTunerSessions[0].getConfiguration();
 
-        assertWithMessage("Session configuration").that(config)
+        expect.withMessage("Session configuration").that(config)
                 .isEqualTo(FM_BAND_CONFIG);
     }
 
@@ -271,7 +296,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
 
         mTunerSessions[0].setMuted(/* mute= */ false);
 
-        assertWithMessage("Session mute state after setting unmuted")
+        expect.withMessage("Session mute state after setting unmuted")
                 .that(mTunerSessions[0].isMuted()).isFalse();
     }
 
@@ -281,7 +306,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
 
         mTunerSessions[0].setMuted(/* mute= */ true);
 
-        assertWithMessage("Session mute state after setting muted")
+        expect.withMessage("Session mute state after setting muted")
                 .that(mTunerSessions[0].isMuted()).isTrue();
     }
 
@@ -291,7 +316,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
 
         mTunerSessions[0].close();
 
-        assertWithMessage("Close state of broadcast radio service session")
+        expect.withMessage("Close state of broadcast radio service session")
                 .that(mTunerSessions[0].isClosed()).isTrue();
     }
 
@@ -305,11 +330,11 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
 
         for (int index = 0; index < numSessions; index++) {
             if (index == closeIdx) {
-                assertWithMessage(
+                expect.withMessage(
                         "Close state of broadcast radio service session of index %s", index)
                         .that(mTunerSessions[index].isClosed()).isTrue();
             } else {
-                assertWithMessage(
+                expect.withMessage(
                         "Close state of broadcast radio service session of index %s", index)
                         .that(mTunerSessions[index].isClosed()).isFalse();
             }
@@ -324,7 +349,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         mTunerSessions[0].close(errorCode);
 
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onError(errorCode);
-        assertWithMessage("Close state of broadcast radio service session")
+        expect.withMessage("Close state of broadcast radio service session")
                 .that(mTunerSessions[0].isClosed()).isTrue();
     }
 
@@ -338,7 +363,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
 
         for (int index = 0; index < numSessions; index++) {
             verify(mAidlTunerCallbackMocks[index], CALLBACK_TIMEOUT).onError(errorCode);
-            assertWithMessage("Close state of broadcast radio service session of index %s", index)
+            expect.withMessage("Close state of broadcast radio service session of index %s", index)
                     .that(mTunerSessions[index].isClosed()).isTrue();
         }
     }
@@ -387,22 +412,12 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
 
     @Test
     public void tune_withUnsupportedSelector_throwsException() throws Exception {
-        ProgramSelector.Identifier dabPrimaryId =
-                new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_DMB_SID_EXT,
-                        /* value= */ 0xA000000111L);
-        ProgramSelector.Identifier[] dabSecondaryIds =  new ProgramSelector.Identifier[]{
-                new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_ENSEMBLE,
-                        /* value= */ 1337),
-                new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_FREQUENCY,
-                        /* value= */ 225648)};
-        ProgramSelector unsupportedSelector = new ProgramSelector(ProgramSelector.PROGRAM_TYPE_DAB,
-                dabPrimaryId, dabSecondaryIds, /* vendorIds= */ null);
         openAidlClients(/* numClients= */ 1);
 
         UnsupportedOperationException thrown = assertThrows(UnsupportedOperationException.class,
-                () -> mTunerSessions[0].tune(unsupportedSelector));
+                () -> mTunerSessions[0].tune(TEST_DAB_SELECTOR));
 
-        assertWithMessage("Exception for tuning on unsupported program selector")
+        expect.withMessage("Exception for tuning on unsupported program selector")
                 .that(thrown).hasMessageThat().contains("tune: NOT_SUPPORTED");
     }
 
@@ -417,7 +432,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class,
                 () -> mTunerSessions[0].tune(invalidSel));
 
-        assertWithMessage("Exception for tuning on DAB selector without DAB_SID_EXT primary id")
+        expect.withMessage("Exception for tuning on DAB selector without DAB_SID_EXT primary id")
                 .that(thrown).hasMessageThat().contains("tune: INVALID_ARGUMENTS");
     }
 
@@ -461,7 +476,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].tune(sel);
         });
 
-        assertWithMessage("Unknown error HAL exception when tuning")
+        expect.withMessage("Unknown error HAL exception when tuning")
                 .that(thrown).hasMessageThat().contains("UNKNOWN_ERROR");
     }
 
@@ -524,7 +539,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].step(/* directionDown= */ true, /* skipSubChannel= */ false);
         });
 
-        assertWithMessage("Exception for stepping when HAL is in invalid state")
+        expect.withMessage("Exception for stepping when HAL is in invalid state")
                 .that(thrown).hasMessageThat().contains("INVALID_STATE");
     }
 
@@ -603,7 +618,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].seek(/* directionDown= */ true, /* skipSubChannel= */ false);
         });
 
-        assertWithMessage("Internal error HAL exception when seeking")
+        expect.withMessage("Internal error HAL exception when seeking")
                 .that(thrown).hasMessageThat().contains("INTERNAL_ERROR");
     }
 
@@ -640,7 +655,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].cancel();
         });
 
-        assertWithMessage("Exception for canceling when HAL throws remote exception")
+        expect.withMessage("Exception for canceling when HAL throws remote exception")
                 .that(thrown).hasMessageThat().contains(exceptionMessage);
     }
 
@@ -653,7 +668,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].getImage(imageId);
         });
 
-        assertWithMessage("Get image exception")
+        expect.withMessage("Get image exception")
                 .that(thrown).hasMessageThat().contains("Image ID is missing");
     }
 
@@ -664,7 +679,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
 
         Bitmap imageTest = mTunerSessions[0].getImage(imageId);
 
-        assertWithMessage("Null image").that(imageTest).isEqualTo(null);
+        expect.withMessage("Null image").that(imageTest).isEqualTo(null);
     }
 
     @Test
@@ -678,7 +693,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].getImage(/* id= */ 1);
         });
 
-        assertWithMessage("Exception for getting image when HAL throws remote exception")
+        expect.withMessage("Exception for getting image when HAL throws remote exception")
                 .that(thrown).hasMessageThat().contains(exceptionMessage);
     }
 
@@ -706,8 +721,8 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         openAidlClients(/* numClients= */ 1);
         ProgramList.Filter filter = new ProgramList.Filter(new ArraySet<>(), new ArraySet<>(),
                 /* includeCategories= */ true, /* excludeModifications= */ false);
-        ProgramFilter halFilter = ConversionUtils.filterToHalProgramFilter(filter);
-        List<RadioManager.ProgramInfo> modified = List.of(TEST_FM_INFO, TEST_RDS_INFO);
+        List<RadioManager.ProgramInfo> modified = List.of(TEST_FM_INFO, TEST_DAB_INFO,
+                TEST_DAB_INFO_ALT);
         List<ProgramSelector.Identifier> halRemoved = new ArrayList<>();
         List<UniqueProgramIdentifier> removed = new ArrayList<>();
         ProgramListChunk halProgramList = AidlTestUtils.makeHalChunk(/* purge= */ true,
@@ -718,7 +733,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         mTunerSessions[0].startProgramListUpdates(filter);
         mHalTunerCallback.onProgramListUpdated(halProgramList);
 
-        verify(mBroadcastRadioMock).startProgramListUpdates(halFilter);
+        verifyHalProgramListUpdatesInvocation(filter);
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT)
                 .onProgramListUpdated(expectedProgramList);
     }
@@ -728,19 +743,23 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         openAidlClients(/* numClients= */ 1);
         ProgramList.Filter filter = new ProgramList.Filter(new ArraySet<>(), new ArraySet<>(),
                 /* includeCategories= */ true, /* excludeModifications= */ false);
+        List<RadioManager.ProgramInfo> modifiedInfo = List.of(TEST_FM_INFO, TEST_DAB_INFO,
+                TEST_DAB_INFO_ALT);
         mTunerSessions[0].startProgramListUpdates(filter);
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ true,
-                /* complete= */ true, List.of(TEST_FM_INFO, TEST_RDS_INFO), new ArrayList<>()));
+                /* complete= */ true, modifiedInfo, new ArrayList<>()));
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(
-                AidlTestUtils.makeChunk(/* purge= */ true, /* complete= */ true,
-                        List.of(TEST_FM_INFO, TEST_RDS_INFO), new ArrayList<>()));
+                AidlTestUtils.makeChunk(/* purge= */ true, /* complete= */ true, modifiedInfo,
+                        new ArrayList<>()));
 
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ false,
-                /* complete= */ true, List.of(TEST_FM_INFO_MODIFIED), List.of(TEST_RDS_PI_ID)));
+                /* complete= */ true, List.of(TEST_FM_INFO_MODIFIED),
+                List.of(TEST_DAB_SID_EXT_ID)));
 
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(
                 AidlTestUtils.makeChunk(/* purge= */ false, /* complete= */ true,
-                        List.of(TEST_FM_INFO_MODIFIED), List.of(TEST_RDS_PI_UNIQUE_ID)));
+                        List.of(TEST_FM_INFO_MODIFIED),
+                        List.of(TEST_DAB_UNIQUE_ID, TEST_DAB_UNIQUE_ID_ALT)));
     }
 
     @Test
@@ -748,17 +767,21 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         openAidlClients(/* numClients= */ 1);
         ProgramList.Filter filter = new ProgramList.Filter(new ArraySet<>(), new ArraySet<>(),
                 /* includeCategories= */ true, /* excludeModifications= */ false);
+        List<RadioManager.ProgramInfo> modifiedInfo = List.of(TEST_FM_INFO, TEST_DAB_INFO,
+                TEST_DAB_INFO_ALT);
         mTunerSessions[0].startProgramListUpdates(filter);
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ true,
-                /* complete= */ true, List.of(TEST_FM_INFO, TEST_RDS_INFO), new ArrayList<>()));
+                /* complete= */ true, modifiedInfo, new ArrayList<>()));
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(
-                AidlTestUtils.makeChunk(/* purge= */ true, /* complete= */ true,
-                        List.of(TEST_FM_INFO, TEST_RDS_INFO), new ArrayList<>()));
+                AidlTestUtils.makeChunk(/* purge= */ true, /* complete= */ true, modifiedInfo,
+                        new ArrayList<>()));
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ false,
-                /* complete= */ true, List.of(TEST_FM_INFO_MODIFIED), List.of(TEST_RDS_PI_ID)));
+                /* complete= */ true, List.of(TEST_FM_INFO_MODIFIED),
+                List.of(TEST_DAB_SID_EXT_ID)));
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(
                 AidlTestUtils.makeChunk(/* purge= */ false, /* complete= */ true,
-                        List.of(TEST_FM_INFO_MODIFIED), List.of(TEST_RDS_PI_UNIQUE_ID)));
+                        List.of(TEST_FM_INFO_MODIFIED),
+                        List.of(TEST_DAB_UNIQUE_ID, TEST_DAB_UNIQUE_ID_ALT)));
 
         mTunerSessions[0].startProgramListUpdates(filter);
 
@@ -771,40 +794,44 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
     @Test
     public void startProgramListUpdates_withNullFilter() throws Exception {
         openAidlClients(/* numClients= */ 1);
+        List<RadioManager.ProgramInfo> modifiedInfo = List.of(TEST_FM_INFO, TEST_DAB_INFO,
+                TEST_DAB_INFO_ALT);
 
         mTunerSessions[0].startProgramListUpdates(/* filter= */ null);
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ true,
-                /* complete= */ true, List.of(TEST_FM_INFO, TEST_RDS_INFO), new ArrayList<>()));
+                /* complete= */ true, modifiedInfo, new ArrayList<>()));
 
         verify(mBroadcastRadioMock).startProgramListUpdates(any());
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(
-                AidlTestUtils.makeChunk(/* purge= */ true, /* complete= */ true,
-                        List.of(TEST_FM_INFO, TEST_RDS_INFO), new ArrayList<>()));
+                AidlTestUtils.makeChunk(/* purge= */ true, /* complete= */ true, modifiedInfo,
+                        new ArrayList<>()));
 
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ false,
-                /* complete= */ true, List.of(TEST_FM_INFO_MODIFIED), List.of(TEST_RDS_PI_ID)));
+                /* complete= */ true, List.of(TEST_FM_INFO_MODIFIED),
+                List.of(TEST_DAB_SID_EXT_ID)));
 
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(
                 AidlTestUtils.makeChunk(/* purge= */ false, /* complete= */ true,
-                        List.of(TEST_FM_INFO_MODIFIED), List.of(TEST_RDS_PI_UNIQUE_ID)));
+                        List.of(TEST_FM_INFO_MODIFIED),
+                        List.of(TEST_DAB_UNIQUE_ID, TEST_DAB_UNIQUE_ID_ALT)));
     }
 
     @Test
     public void startProgramListUpdates_withIdFilter() throws Exception {
         openAidlClients(/* numClients= */ 1);
         ProgramList.Filter idFilter = new ProgramList.Filter(new ArraySet<>(),
-                Set.of(TEST_RDS_PI_ID), /* includeCategories= */ true,
+                Set.of(TEST_DAB_SID_EXT_ID), /* includeCategories= */ true,
                 /* excludeModifications= */ true);
-        ProgramFilter halFilter = ConversionUtils.filterToHalProgramFilter(idFilter);
 
         mTunerSessions[0].startProgramListUpdates(idFilter);
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ false,
-                /* complete= */ true, List.of(TEST_RDS_INFO), new ArrayList<>()));
+                /* complete= */ true, List.of(TEST_DAB_INFO, TEST_DAB_INFO_ALT),
+                new ArrayList<>()));
 
-        verify(mBroadcastRadioMock).startProgramListUpdates(halFilter);
+        verifyHalProgramListUpdatesInvocation(idFilter);
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(
                 AidlTestUtils.makeChunk(/* purge= */ false, /* complete= */ true,
-                        List.of(TEST_RDS_INFO), new ArrayList<>()));
+                        List.of(TEST_DAB_INFO, TEST_DAB_INFO_ALT), new ArrayList<>()));
 
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ false,
                 /* complete= */ true, List.of(TEST_FM_INFO), new ArrayList<>()));
@@ -816,50 +843,52 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
     public void startProgramListUpdates_withFilterExcludingModifications() throws Exception {
         openAidlClients(/* numClients= */ 1);
         ProgramList.Filter filterExcludingModifications = new ProgramList.Filter(
-                Set.of(ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY), new ArraySet<>(),
+                Set.of(ProgramSelector.IDENTIFIER_TYPE_DAB_DMB_SID_EXT,
+                        ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY), new ArraySet<>(),
                 /* includeCategories= */ true, /* excludeModifications= */ true);
-        ProgramFilter halFilter =
-                ConversionUtils.filterToHalProgramFilter(filterExcludingModifications);
 
         mTunerSessions[0].startProgramListUpdates(filterExcludingModifications);
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ false,
-                /* complete= */ true, List.of(TEST_FM_INFO), new ArrayList<>()));
+                /* complete= */ true, List.of(TEST_FM_INFO, TEST_DAB_INFO), new ArrayList<>()));
 
-        verify(mBroadcastRadioMock).startProgramListUpdates(halFilter);
+        verifyHalProgramListUpdatesInvocation(filterExcludingModifications);
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(
                 AidlTestUtils.makeChunk(/* purge= */ false, /* complete= */ true,
-                        List.of(TEST_FM_INFO), new ArrayList<>()));
+                        List.of(TEST_FM_INFO, TEST_DAB_INFO), new ArrayList<>()));
 
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ false,
-                /* complete= */ true, List.of(TEST_FM_INFO_MODIFIED), new ArrayList<>()));
+                /* complete= */ true, List.of(TEST_FM_INFO_MODIFIED, TEST_DAB_INFO_ALT),
+                new ArrayList<>()));
 
-        verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(any());
+        verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(
+                AidlTestUtils.makeChunk(/* purge= */ false, /* complete= */ true,
+                        List.of(TEST_DAB_INFO_ALT), new ArrayList<>()));
     }
 
     @Test
     public void startProgramListUpdates_withFilterIncludingModifications() throws Exception {
         openAidlClients(/* numClients= */ 1);
         ProgramList.Filter filterIncludingModifications = new ProgramList.Filter(
-                Set.of(ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY), new ArraySet<>(),
+                Set.of(ProgramSelector.IDENTIFIER_TYPE_DAB_DMB_SID_EXT,
+                        ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY), new ArraySet<>(),
                 /* includeCategories= */ true, /* excludeModifications= */ false);
-        ProgramFilter halFilter =
-                ConversionUtils.filterToHalProgramFilter(filterIncludingModifications);
 
         mTunerSessions[0].startProgramListUpdates(filterIncludingModifications);
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ false,
-                /* complete= */ true, List.of(TEST_FM_INFO), new ArrayList<>()));
+                /* complete= */ true, List.of(TEST_FM_INFO, TEST_DAB_INFO), new ArrayList<>()));
 
-        verify(mBroadcastRadioMock).startProgramListUpdates(halFilter);
+        verifyHalProgramListUpdatesInvocation(filterIncludingModifications);
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(
                 AidlTestUtils.makeChunk(/* purge= */ false, /* complete= */ true,
-                        List.of(TEST_FM_INFO), new ArrayList<>()));
+                        List.of(TEST_FM_INFO, TEST_DAB_INFO), new ArrayList<>()));
 
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ false,
-                /* complete= */ true, List.of(TEST_FM_INFO_MODIFIED), new ArrayList<>()));
+                /* complete= */ true, List.of(TEST_FM_INFO_MODIFIED, TEST_DAB_INFO_ALT),
+                new ArrayList<>()));
 
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onProgramListUpdated(
                 AidlTestUtils.makeChunk(/* purge= */ false, /* complete= */ true,
-                        List.of(TEST_FM_INFO_MODIFIED), new ArrayList<>()));
+                        List.of(TEST_FM_INFO_MODIFIED, TEST_DAB_INFO_ALT), new ArrayList<>()));
     }
 
     @Test
@@ -915,7 +944,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         int numSessions = 3;
         openAidlClients(numSessions);
         List<ProgramList.Filter> filters = List.of(new ProgramList.Filter(
-                        Set.of(ProgramSelector.IDENTIFIER_TYPE_RDS_PI), new ArraySet<>(),
+                        Set.of(ProgramSelector.IDENTIFIER_TYPE_DAB_DMB_SID_EXT), new ArraySet<>(),
                         /* includeCategories= */ true, /* excludeModifications= */ false),
                 new ProgramList.Filter(new ArraySet<>(), Set.of(TEST_FM_FREQUENCY_ID),
                         /* includeCategories= */ false, /* excludeModifications= */ true),
@@ -927,18 +956,20 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         }
 
         mHalTunerCallback.onProgramListUpdated(AidlTestUtils.makeHalChunk(/* purge= */ false,
-                /* complete= */ true, List.of(TEST_FM_INFO, TEST_RDS_INFO), new ArrayList<>()));
+                /* complete= */ true, List.of(TEST_FM_INFO, TEST_DAB_INFO, TEST_DAB_INFO_ALT),
+                new ArrayList<>()));
 
         verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT)
                 .onProgramListUpdated(AidlTestUtils.makeChunk(/* purge= */ false,
-                        /* complete= */ true, List.of(TEST_RDS_INFO), new ArrayList<>()));
+                        /* complete= */ true, List.of(TEST_DAB_INFO, TEST_DAB_INFO_ALT),
+                        new ArrayList<>()));
         verify(mAidlTunerCallbackMocks[1], CALLBACK_TIMEOUT)
                 .onProgramListUpdated(AidlTestUtils.makeChunk(/* purge= */ false,
                         /* complete= */ true, List.of(TEST_FM_INFO), new ArrayList<>()));
         verify(mAidlTunerCallbackMocks[2], CALLBACK_TIMEOUT)
                 .onProgramListUpdated(AidlTestUtils.makeChunk(/* purge= */ false,
-                        /* complete= */ true, List.of(TEST_RDS_INFO, TEST_FM_INFO),
-                        new ArrayList<>()));
+                        /* complete= */ true, List.of(TEST_DAB_INFO, TEST_DAB_INFO_ALT,
+                                TEST_FM_INFO), new ArrayList<>()));
     }
 
     @Test
@@ -963,7 +994,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].startProgramListUpdates(/* filter= */ null);
         });
 
-        assertWithMessage("Unknown error HAL exception when updating program list")
+        expect.withMessage("Unknown error HAL exception when updating program list")
                 .that(thrown).hasMessageThat().contains("UNKNOWN_ERROR");
     }
 
@@ -1000,7 +1031,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         boolean isSupported = mTunerSessions[0].isConfigFlagSupported(flag);
 
         verify(mBroadcastRadioMock).isConfigFlagSet(flag);
-        assertWithMessage("Config flag %s is supported", flag).that(isSupported).isFalse();
+        expect.withMessage("Config flag %s is supported", flag).that(isSupported).isFalse();
     }
 
     @Test
@@ -1011,7 +1042,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         boolean isSupported = mTunerSessions[0].isConfigFlagSupported(flag);
 
         verify(mBroadcastRadioMock).isConfigFlagSet(flag);
-        assertWithMessage("Config flag %s is supported", flag).that(isSupported).isTrue();
+        expect.withMessage("Config flag %s is supported", flag).that(isSupported).isTrue();
     }
 
     @Test
@@ -1023,7 +1054,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].setConfigFlag(flag, /* value= */ true);
         });
 
-        assertWithMessage("Exception for setting unsupported flag %s", flag)
+        expect.withMessage("Exception for setting unsupported flag %s", flag)
                 .that(thrown).hasMessageThat().contains("setConfigFlag: NOT_SUPPORTED");
     }
 
@@ -1068,7 +1099,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].isConfigFlagSet(flag);
         });
 
-        assertWithMessage("Exception for checking if unsupported flag %s is set", flag)
+        expect.withMessage("Exception for checking if unsupported flag %s is set", flag)
                 .that(thrown).hasMessageThat().contains("isConfigFlagSet: NOT_SUPPORTED");
     }
 
@@ -1081,7 +1112,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
 
         boolean isSet = mTunerSessions[0].isConfigFlagSet(flag);
 
-        assertWithMessage("Config flag %s is set", flag)
+        expect.withMessage("Config flag %s is set", flag)
                 .that(isSet).isEqualTo(expectedConfigFlagValue);
     }
 
@@ -1095,7 +1126,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].isConfigFlagSet(flag);
         });
 
-        assertWithMessage("Exception for checking config flag when HAL throws remote exception")
+        expect.withMessage("Exception for checking config flag when HAL throws remote exception")
                 .that(thrown).hasMessageThat().contains("Failed to check flag");
     }
 
@@ -1136,7 +1167,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].setParameters(parametersSet);
         });
 
-        assertWithMessage("Exception for setting parameters when HAL throws remote exception")
+        expect.withMessage("Exception for setting parameters when HAL throws remote exception")
                 .that(thrown).hasMessageThat().contains(exceptionMessage);
     }
 
@@ -1162,7 +1193,7 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
             mTunerSessions[0].getParameters(parameterKeys);
         });
 
-        assertWithMessage("Exception for getting parameters when HAL throws remote exception")
+        expect.withMessage("Exception for getting parameters when HAL throws remote exception")
                 .that(thrown).hasMessageThat().contains(exceptionMessage);
     }
 
@@ -1269,4 +1300,24 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase {
         }
         return seekFrequency;
     }
+
+    private void verifyHalProgramListUpdatesInvocation(ProgramList.Filter filter) throws Exception {
+        ProgramFilter halFilterExpected = ConversionUtils.filterToHalProgramFilter(filter);
+        ArgumentCaptor<ProgramFilter> halFilterCaptor = ArgumentCaptor.forClass(
+                ProgramFilter.class);
+        verify(mBroadcastRadioMock).startProgramListUpdates(halFilterCaptor.capture());
+        ProgramFilter halFilterInvoked = halFilterCaptor.getValue();
+        expect.withMessage("Filtered identifier types").that(
+                halFilterInvoked.identifierTypes).asList().containsExactlyElementsIn(Arrays.stream(
+                        halFilterExpected.identifierTypes).boxed().toArray(Integer[]::new));
+        expect.withMessage("Filtered identifiers").that(
+                halFilterInvoked.identifiers).asList()
+                .containsExactlyElementsIn(halFilterExpected.identifiers);
+        expect.withMessage("Categories-included filter")
+                .that(halFilterInvoked.includeCategories)
+                .isEqualTo(halFilterExpected.includeCategories);
+        expect.withMessage("Modifications-excluded filter")
+                .that(halFilterInvoked.excludeModifications)
+                .isEqualTo(halFilterExpected.excludeModifications);
+    }
 }