Migrate & adapt database tests to Kotlin as well

Signed-off-by: Aayush Gupta <aayushgupta219@gmail.com>

app/src/androidTest/java/org/schabi/newpipe/database/DatabaseMigrationTest.kt

@@ -129,7 +129,7 @@ class DatabaseMigrationTest {
         )
 
         val migratedDatabaseV3 = getMigratedDatabase()
-        val listFromDB = migratedDatabaseV3.streamDAO().all.blockingFirst()
+        val listFromDB = migratedDatabaseV3.streamDAO().getAll().blockingFirst()
 
         // Only expect 2, the one with the null url will be ignored
         assertEquals(2, listFromDB.size)
@@ -217,7 +217,7 @@ class DatabaseMigrationTest {
         )
 
         val migratedDatabaseV8 = getMigratedDatabase()
-        val listFromDB = migratedDatabaseV8.searchHistoryDAO().all.blockingFirst()
+        val listFromDB = migratedDatabaseV8.searchHistoryDAO().getAll().blockingFirst()
 
         assertEquals(2, listFromDB.size)
         assertEquals("abc", listFromDB[0].search)
@@ -283,8 +283,8 @@ class DatabaseMigrationTest {
         )
 
         val migratedDatabaseV9 = getMigratedDatabase()
-        var localListFromDB = migratedDatabaseV9.playlistDAO().all.blockingFirst()
+        var localListFromDB = migratedDatabaseV9.playlistDAO().getAll().blockingFirst()
-        var remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().all.blockingFirst()
+        var remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().getAll().blockingFirst()
 
         assertEquals(1, localListFromDB.size)
         assertEquals(localUid2, localListFromDB[0].uid)
@@ -294,17 +294,27 @@ class DatabaseMigrationTest {
         assertEquals(-1, remoteListFromDB[0].displayIndex)
 
         val localUid3 = migratedDatabaseV9.playlistDAO().insert(
-            PlaylistEntity(DEFAULT_NAME + "3", false, -1, -1)
+            PlaylistEntity(
+                name = "${DEFAULT_NAME}3",
+                isThumbnailPermanent = false,
+                thumbnailStreamId = -1,
+                displayIndex = -1
+            )
         )
         val remoteUid3 = migratedDatabaseV9.playlistRemoteDAO().insert(
             PlaylistRemoteEntity(
-                DEFAULT_THIRD_SERVICE_ID, DEFAULT_NAME, DEFAULT_THIRD_URL,
+                serviceId = DEFAULT_THIRD_SERVICE_ID,
-                DEFAULT_THUMBNAIL, DEFAULT_UPLOADER_NAME, -1, 10
+                orderingName = DEFAULT_NAME,
+                url = DEFAULT_THIRD_URL,
+                thumbnailUrl = DEFAULT_THUMBNAIL,
+                uploader = DEFAULT_UPLOADER_NAME,
+                displayIndex = -1,
+                streamCount = 10
             )
         )
 
-        localListFromDB = migratedDatabaseV9.playlistDAO().all.blockingFirst()
+        localListFromDB = migratedDatabaseV9.playlistDAO().getAll().blockingFirst()
-        remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().all.blockingFirst()
+        remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().getAll().blockingFirst()
         assertEquals(2, localListFromDB.size)
         assertEquals(localUid3, localListFromDB[1].uid)
         assertEquals(-1, localListFromDB[1].displayIndex)

app/src/androidTest/java/org/schabi/newpipe/local/history/HistoryRecordManagerTest.kt

@@ -41,7 +41,7 @@ class HistoryRecordManagerTest {
         // For some reason the Flowable returned by getAll() never completes, so we can't assert
         // that the number of Lists it returns is exactly 1, we can only check if the first List is
         // correct. Why on earth has a Flowable been used instead of a Single for getAll()?!?
-        val entities = database.searchHistoryDAO().all.blockingFirst()
+        val entities = database.searchHistoryDAO().getAll().blockingFirst()
         assertThat(entities).hasSize(1)
         assertThat(entities[0].id).isEqualTo(1)
         assertThat(entities[0].serviceId).isEqualTo(0)
@@ -51,50 +51,50 @@ class HistoryRecordManagerTest {
     @Test
     fun deleteSearchHistory() {
         val entries = listOf(
-            SearchHistoryEntry(time.minusSeconds(1), 0, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 0, search = "A"),
-            SearchHistoryEntry(time.minusSeconds(2), 2, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 2, search = "A"),
-            SearchHistoryEntry(time.minusSeconds(3), 1, "B"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 1, search = "B"),
-            SearchHistoryEntry(time.minusSeconds(4), 0, "B"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(4), serviceId = 0, search = "B"),
         )
 
         // make sure all 4 were inserted
         database.searchHistoryDAO().insertAll(entries)
-        assertThat(database.searchHistoryDAO().all.blockingFirst()).hasSameSizeAs(entries)
+        assertThat(database.searchHistoryDAO().getAll().blockingFirst()).hasSameSizeAs(entries)
 
         // try to delete only "A" entries, "B" entries should be untouched
         manager.deleteSearchHistory("A").test().await().assertValue(2)
-        val entities = database.searchHistoryDAO().all.blockingFirst()
+        val entities = database.searchHistoryDAO().getAll().blockingFirst()
         assertThat(entities).hasSize(2)
         assertThat(entities).usingElementComparator { o1, o2 -> if (o1.hasEqualValues(o2)) 0 else 1 }
             .containsExactly(*entries.subList(2, 4).toTypedArray())
 
         // assert that nothing happens if we delete a search query that does exist in the db
         manager.deleteSearchHistory("A").test().await().assertValue(0)
-        val entities2 = database.searchHistoryDAO().all.blockingFirst()
+        val entities2 = database.searchHistoryDAO().getAll().blockingFirst()
         assertThat(entities2).hasSize(2)
         assertThat(entities2).usingElementComparator { o1, o2 -> if (o1.hasEqualValues(o2)) 0 else 1 }
             .containsExactly(*entries.subList(2, 4).toTypedArray())
 
         // delete all remaining entries
         manager.deleteSearchHistory("B").test().await().assertValue(2)
-        assertThat(database.searchHistoryDAO().all.blockingFirst()).isEmpty()
+        assertThat(database.searchHistoryDAO().getAll().blockingFirst()).isEmpty()
     }
 
     @Test
     fun deleteCompleteSearchHistory() {
         val entries = listOf(
-            SearchHistoryEntry(time.minusSeconds(1), 1, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 1, search = "A"),
-            SearchHistoryEntry(time.minusSeconds(2), 2, "B"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 2, search = "B"),
-            SearchHistoryEntry(time.minusSeconds(3), 0, "C"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 0, search = "C"),
         )
 
         // make sure all 3 were inserted
         database.searchHistoryDAO().insertAll(entries)
-        assertThat(database.searchHistoryDAO().all.blockingFirst()).hasSameSizeAs(entries)
+        assertThat(database.searchHistoryDAO().getAll().blockingFirst()).hasSameSizeAs(entries)
 
         // should remove everything
         manager.deleteCompleteSearchHistory().test().await().assertValue(entries.size)
-        assertThat(database.searchHistoryDAO().all.blockingFirst()).isEmpty()
+        assertThat(database.searchHistoryDAO().getAll().blockingFirst()).isEmpty()
     }
 
     private fun insertShuffledRelatedSearches(relatedSearches: Collection<SearchHistoryEntry>) {
@@ -107,7 +107,7 @@ class HistoryRecordManagerTest {
         // make sure all entries were inserted
         assertEquals(
             relatedSearches.size,
-            database.searchHistoryDAO().all.blockingFirst().size
+            database.searchHistoryDAO().getAll().blockingFirst().size
         )
     }
 
@@ -127,19 +127,18 @@ class HistoryRecordManagerTest {
 
     @Test
     fun getRelatedSearches_emptyQuery_manyDuplicates() {
-        insertShuffledRelatedSearches(
+        val relatedSearches = listOf(
-            listOf(
+            SearchHistoryEntry(creationDate = time.minusSeconds(9), serviceId = 3, search = "A"),
-                SearchHistoryEntry(time.minusSeconds(9), 3, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(8), serviceId = 3, search = "AB"),
-                SearchHistoryEntry(time.minusSeconds(8), 3, "AB"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(7), serviceId = 3, search = "A"),
-                SearchHistoryEntry(time.minusSeconds(7), 3, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(6), serviceId = 3, search = "A"),
-                SearchHistoryEntry(time.minusSeconds(6), 3, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(5), serviceId = 3, search = "BA"),
-                SearchHistoryEntry(time.minusSeconds(5), 3, "BA"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(4), serviceId = 3, search = "A"),
-                SearchHistoryEntry(time.minusSeconds(4), 3, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 3, search = "A"),
-                SearchHistoryEntry(time.minusSeconds(3), 3, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 0, search = "A"),
-                SearchHistoryEntry(time.minusSeconds(2), 0, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 2, search = "AA"),
-                SearchHistoryEntry(time.minusSeconds(1), 2, "AA"),
-            )
         )
+        insertShuffledRelatedSearches(relatedSearches)
 
         val searches = manager.getRelatedSearches("", 9, 3).blockingFirst()
         assertThat(searches).containsExactly("AA", "A", "BA")
@@ -166,13 +165,13 @@ class HistoryRecordManagerTest {
         private val time = OffsetDateTime.of(LocalDateTime.of(2000, 1, 1, 1, 1), ZoneOffset.UTC)
 
         private val RELATED_SEARCHES_ENTRIES = listOf(
-            SearchHistoryEntry(time.minusSeconds(7), 2, "AC"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(7), serviceId = 2, search = "AC"),
-            SearchHistoryEntry(time.minusSeconds(6), 0, "ABC"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(6), serviceId = 0, search = "ABC"),
-            SearchHistoryEntry(time.minusSeconds(5), 1, "BA"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(5), serviceId = 1, search = "BA"),
-            SearchHistoryEntry(time.minusSeconds(4), 3, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(4), serviceId = 3, search = "A"),
-            SearchHistoryEntry(time.minusSeconds(2), 0, "B"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 0, search = "B"),
-            SearchHistoryEntry(time.minusSeconds(3), 2, "AA"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 2, search = "AA"),
-            SearchHistoryEntry(time.minusSeconds(1), 1, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 1, search = "A"),
         )
     }
 }

app/src/androidTest/java/org/schabi/newpipe/local/playlist/LocalPlaylistManagerTest.kt

@@ -72,6 +72,6 @@ class LocalPlaylistManagerTest {
         val result = manager.createPlaylist("name", listOf(stream, upserted))
 
         result.test().await().assertComplete()
-        database.streamDAO().all.test().awaitCount(1).assertValue(listOf(stream, upserted))
+        database.streamDAO().getAll().test().awaitCount(1).assertValue(listOf(stream, upserted))
     }
 }

app/src/test/java/org/schabi/newpipe/database/playlist/PlaylistLocalItemTest.java

@@ -1,106 +0,0 @@
-package org.schabi.newpipe.database.playlist;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-import org.schabi.newpipe.database.playlist.model.PlaylistRemoteEntity;
-import org.schabi.newpipe.local.bookmark.MergedPlaylistManager;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class PlaylistLocalItemTest {
-    @Test
-    public void emptyPlaylists() {
-        final List<PlaylistMetadataEntry> localPlaylists = new ArrayList<>();
-        final List<PlaylistRemoteEntity> remotePlaylists = new ArrayList<>();
-        final List<PlaylistLocalItem> mergedPlaylists =
-                MergedPlaylistManager.merge(localPlaylists, remotePlaylists);
-
-        assertEquals(0, mergedPlaylists.size());
-    }
-
-    @Test
-    public void onlyLocalPlaylists() {
-        final List<PlaylistMetadataEntry> localPlaylists = new ArrayList<>();
-        final List<PlaylistRemoteEntity> remotePlaylists = new ArrayList<>();
-        localPlaylists.add(new PlaylistMetadataEntry(1, "name1", "", false, -1, 0, 1));
-        localPlaylists.add(new PlaylistMetadataEntry(2, "name2", "", false, -1, 1, 1));
-        localPlaylists.add(new PlaylistMetadataEntry(3, "name3", "", false, -1, 3, 1));
-        final List<PlaylistLocalItem> mergedPlaylists =
-                MergedPlaylistManager.merge(localPlaylists, remotePlaylists);
-
-        assertEquals(3, mergedPlaylists.size());
-        assertEquals(0, mergedPlaylists.get(0).getDisplayIndex());
-        assertEquals(1, mergedPlaylists.get(1).getDisplayIndex());
-        assertEquals(3, mergedPlaylists.get(2).getDisplayIndex());
-    }
-
-    @Test
-    public void onlyRemotePlaylists() {
-        final List<PlaylistMetadataEntry> localPlaylists = new ArrayList<>();
-        final List<PlaylistRemoteEntity> remotePlaylists = new ArrayList<>();
-        remotePlaylists.add(new PlaylistRemoteEntity(
-                1, "name1", "url1", "", "", 1, 1L));
-        remotePlaylists.add(new PlaylistRemoteEntity(
-                2, "name2", "url2", "", "", 2, 1L));
-        remotePlaylists.add(new PlaylistRemoteEntity(
-                3, "name3", "url3", "", "", 4, 1L));
-        final List<PlaylistLocalItem> mergedPlaylists =
-                MergedPlaylistManager.merge(localPlaylists, remotePlaylists);
-
-        assertEquals(3, mergedPlaylists.size());
-        assertEquals(1, mergedPlaylists.get(0).getDisplayIndex());
-        assertEquals(2, mergedPlaylists.get(1).getDisplayIndex());
-        assertEquals(4, mergedPlaylists.get(2).getDisplayIndex());
-    }
-
-    @Test
-    public void sameIndexWithDifferentName() {
-        final List<PlaylistMetadataEntry> localPlaylists = new ArrayList<>();
-        final List<PlaylistRemoteEntity> remotePlaylists = new ArrayList<>();
-        localPlaylists.add(new PlaylistMetadataEntry(1, "name1", "", false, -1, 0, 1));
-        localPlaylists.add(new PlaylistMetadataEntry(2, "name2", "", false, -1, 1, 1));
-        remotePlaylists.add(new PlaylistRemoteEntity(
-                1, "name3", "url1", "", "", 0, 1L));
-        remotePlaylists.add(new PlaylistRemoteEntity(
-                2, "name4", "url2", "", "", 1, 1L));
-        final List<PlaylistLocalItem> mergedPlaylists =
-                MergedPlaylistManager.merge(localPlaylists, remotePlaylists);
-
-        assertEquals(4, mergedPlaylists.size());
-        assertTrue(mergedPlaylists.get(0) instanceof PlaylistMetadataEntry);
-        assertEquals("name1", ((PlaylistMetadataEntry) mergedPlaylists.get(0)).name);
-        assertTrue(mergedPlaylists.get(1) instanceof PlaylistRemoteEntity);
-        assertEquals("name3", ((PlaylistRemoteEntity) mergedPlaylists.get(1)).getName());
-        assertTrue(mergedPlaylists.get(2) instanceof PlaylistMetadataEntry);
-        assertEquals("name2", ((PlaylistMetadataEntry) mergedPlaylists.get(2)).name);
-        assertTrue(mergedPlaylists.get(3) instanceof PlaylistRemoteEntity);
-        assertEquals("name4", ((PlaylistRemoteEntity) mergedPlaylists.get(3)).getName());
-    }
-
-    @Test
-    public void sameNameWithDifferentIndex() {
-        final List<PlaylistMetadataEntry> localPlaylists = new ArrayList<>();
-        final List<PlaylistRemoteEntity> remotePlaylists = new ArrayList<>();
-        localPlaylists.add(new PlaylistMetadataEntry(1, "name1", "", false, -1, 1, 1));
-        localPlaylists.add(new PlaylistMetadataEntry(2, "name2", "", false, -1, 3, 1));
-        remotePlaylists.add(new PlaylistRemoteEntity(
-                1, "name1", "url1", "", "", 0, 1L));
-        remotePlaylists.add(new PlaylistRemoteEntity(
-                2, "name2", "url2", "", "", 2, 1L));
-        final List<PlaylistLocalItem> mergedPlaylists =
-                MergedPlaylistManager.merge(localPlaylists, remotePlaylists);
-
-        assertEquals(4, mergedPlaylists.size());
-        assertTrue(mergedPlaylists.get(0) instanceof PlaylistRemoteEntity);
-        assertEquals("name1", ((PlaylistRemoteEntity) mergedPlaylists.get(0)).getName());
-        assertTrue(mergedPlaylists.get(1) instanceof PlaylistMetadataEntry);
-        assertEquals("name1", ((PlaylistMetadataEntry) mergedPlaylists.get(1)).name);
-        assertTrue(mergedPlaylists.get(2) instanceof PlaylistRemoteEntity);
-        assertEquals("name2", ((PlaylistRemoteEntity) mergedPlaylists.get(2)).getName());
-        assertTrue(mergedPlaylists.get(3) instanceof PlaylistMetadataEntry);
-        assertEquals("name2", ((PlaylistMetadataEntry) mergedPlaylists.get(3)).name);
-    }
-}

app/src/test/java/org/schabi/newpipe/database/playlist/PlaylistLocalItemTest.kt

@@ -0,0 +1,102 @@
+/*
+ * SPDX-FileCopyrightText: 2022-2024 NewPipe contributors <https://newpipe.net>
+ * SPDX-FileCopyrightText: 2025 NewPipe e.V. <https://newpipe-ev.de>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+package org.schabi.newpipe.database.playlist
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.schabi.newpipe.database.playlist.model.PlaylistRemoteEntity
+import org.schabi.newpipe.local.bookmark.MergedPlaylistManager
+
+class PlaylistLocalItemTest {
+
+    @Test
+    fun emptyPlaylists() {
+        val localPlaylists = listOf<PlaylistMetadataEntry?>()
+        val remotePlaylists = listOf<PlaylistRemoteEntity?>()
+        val mergedPlaylists = MergedPlaylistManager.merge(localPlaylists, remotePlaylists)
+        assertEquals(0, mergedPlaylists.size)
+    }
+
+    @Test
+    fun onlyLocalPlaylists() {
+        val localPlaylists = listOf<PlaylistMetadataEntry?>(
+            PlaylistMetadataEntry(1, "name1", "", 0, false, -1, 1),
+            PlaylistMetadataEntry(2, "name2", "", 1, false, -1, 1),
+            PlaylistMetadataEntry(3, "name3", "", 3, false, -1, 1)
+        )
+        val remotePlaylists = listOf<PlaylistRemoteEntity?>()
+        val mergedPlaylists = MergedPlaylistManager.merge(localPlaylists, remotePlaylists)
+
+        assertEquals(3, mergedPlaylists.size)
+        assertEquals(0L, mergedPlaylists[0]!!.displayIndex)
+        assertEquals(1L, mergedPlaylists[1]!!.displayIndex)
+        assertEquals(3L, mergedPlaylists[2]!!.displayIndex)
+    }
+
+    @Test
+    fun onlyRemotePlaylists() {
+        val localPlaylists = listOf<PlaylistMetadataEntry?>()
+        val remotePlaylists = listOf<PlaylistRemoteEntity?>(
+            PlaylistRemoteEntity(1, 1, "name1", "url1", "", "", 1, 1),
+            PlaylistRemoteEntity(2, 2, "name2", "url2", "", "", 2, 1),
+            PlaylistRemoteEntity(3, 3, "name3", "url3", "", "", 4, 1)
+        )
+        val mergedPlaylists = MergedPlaylistManager.merge(localPlaylists, remotePlaylists)
+
+        assertEquals(3, mergedPlaylists.size)
+        assertEquals(1L, mergedPlaylists[0]!!.displayIndex)
+        assertEquals(2L, mergedPlaylists[1]!!.displayIndex)
+        assertEquals(4L, mergedPlaylists[2]!!.displayIndex)
+    }
+
+    @Test
+    fun sameIndexWithDifferentName() {
+        val localPlaylists = listOf<PlaylistMetadataEntry?>(
+            PlaylistMetadataEntry(1, "name1", "", 0, false, -1, 1),
+            PlaylistMetadataEntry(2, "name2", "", 1, false, -1, 1)
+        )
+        val remotePlaylists = listOf<PlaylistRemoteEntity?>(
+            PlaylistRemoteEntity(1, 1, "name3", "url1", "", "", 0, 1),
+            PlaylistRemoteEntity(2, 2, "name4", "url2", "", "", 1, 1)
+        )
+        val mergedPlaylists = MergedPlaylistManager.merge(localPlaylists, remotePlaylists)
+
+        assertEquals(4, mergedPlaylists.size)
+        assertTrue(mergedPlaylists[0] is PlaylistMetadataEntry)
+        assertEquals("name1", (mergedPlaylists[0] as PlaylistMetadataEntry).orderingName)
+        assertTrue(mergedPlaylists[1] is PlaylistRemoteEntity)
+        assertEquals("name3", (mergedPlaylists[1] as PlaylistRemoteEntity).orderingName)
+        assertTrue(mergedPlaylists[2] is PlaylistMetadataEntry)
+        assertEquals("name2", (mergedPlaylists[2] as PlaylistMetadataEntry).orderingName)
+        assertTrue(mergedPlaylists[3] is PlaylistRemoteEntity)
+        assertEquals("name4", (mergedPlaylists[3] as PlaylistRemoteEntity).orderingName)
+    }
+
+    @Test
+    fun sameNameWithDifferentIndex() {
+        val localPlaylists = listOf<PlaylistMetadataEntry?>(
+            PlaylistMetadataEntry(1, "name1", "", 1, false, -1, 1),
+            PlaylistMetadataEntry(2, "name2", "", 3, false, -1, 1)
+        )
+        val remotePlaylists = listOf<PlaylistRemoteEntity?>(
+            PlaylistRemoteEntity(1, 1, "name1", "url1", "", "", 0, 1),
+            PlaylistRemoteEntity(2, 2, "name2", "url2", "", "", 2, 1)
+        )
+        val mergedPlaylists = MergedPlaylistManager.merge(localPlaylists, remotePlaylists)
+
+        assertEquals(4, mergedPlaylists.size)
+        assertTrue(mergedPlaylists[0] is PlaylistRemoteEntity)
+        assertEquals("name1", (mergedPlaylists[0] as PlaylistRemoteEntity).orderingName)
+        assertTrue(mergedPlaylists[1] is PlaylistMetadataEntry)
+        assertEquals("name1", (mergedPlaylists[1] as PlaylistMetadataEntry).orderingName)
+        assertTrue(mergedPlaylists[2] is PlaylistRemoteEntity)
+        assertEquals("name2", (mergedPlaylists[2] as PlaylistRemoteEntity).orderingName)
+        assertTrue(mergedPlaylists[3] is PlaylistMetadataEntry)
+        assertEquals("name2", (mergedPlaylists[3] as PlaylistMetadataEntry).orderingName)
+    }
+}