Run DbReaderTest etc. with Robolectric

4 files changed, 786 insertions, 0 deletions

diff --git a/core/src/test/java/de/danoeh/antennapod/core/storage/DbCleanupTests.java b/core/src/test/java/de/danoeh/antennapod/core/storage/DbCleanupTests.java
new file mode 100644
index 000000000..13d24adc1
--- /dev/null
+++ b/core/src/test/java/de/danoeh/antennapod/core/storage/DbCleanupTests.java
@@ -0,0 +1,237 @@
+package de.danoeh.antennapod.core.storage;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.SharedPreferences;
+import androidx.preference.PreferenceManager;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import de.danoeh.antennapod.core.ApplicationCallbacks;
+import de.danoeh.antennapod.core.ClientConfig;
+import de.danoeh.antennapod.core.feed.Feed;
+import de.danoeh.antennapod.core.feed.FeedItem;
+import de.danoeh.antennapod.core.feed.FeedMedia;
+import de.danoeh.antennapod.core.preferences.PlaybackPreferences;
+import de.danoeh.antennapod.core.preferences.UserPreferences;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+import static de.danoeh.antennapod.core.storage.DbTestUtils.saveFeedlist;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Test class for DBTasks.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class DbCleanupTests {
+
+    static final int EPISODE_CACHE_SIZE = 5;
+    private int cleanupAlgorithm;
+
+    Context context;
+
+    private File destFolder;
+
+    public DbCleanupTests() {
+        setCleanupAlgorithm(UserPreferences.EPISODE_CLEANUP_DEFAULT);
+    }
+
+    protected void setCleanupAlgorithm(int cleanupAlgorithm) {
+        this.cleanupAlgorithm = cleanupAlgorithm;
+    }
+
+    @Before
+    public void setUp() {
+        context = InstrumentationRegistry.getInstrumentation().getTargetContext();
+        destFolder = new File(context.getCacheDir(), "DbCleanupTests");
+        //noinspection ResultOfMethodCallIgnored
+        destFolder.mkdir();
+        cleanupDestFolder(destFolder);
+        assertNotNull(destFolder);
+        assertTrue(destFolder.exists());
+        assertTrue(destFolder.canWrite());
+
+        // create new database
+        PodDBAdapter.init(context);
+        PodDBAdapter.deleteDatabase();
+        PodDBAdapter adapter = PodDBAdapter.getInstance();
+        adapter.open();
+        adapter.close();
+
+        SharedPreferences.Editor prefEdit = PreferenceManager
+                .getDefaultSharedPreferences(context.getApplicationContext()).edit();
+        prefEdit.putString(UserPreferences.PREF_EPISODE_CACHE_SIZE, Integer.toString(EPISODE_CACHE_SIZE));
+        prefEdit.putString(UserPreferences.PREF_EPISODE_CLEANUP, Integer.toString(cleanupAlgorithm));
+        prefEdit.putBoolean(UserPreferences.PREF_ENABLE_AUTODL, true);
+        prefEdit.commit();
+
+        UserPreferences.init(context);
+        PlaybackPreferences.init(context);
+
+        Application app = (Application) context;
+        ClientConfig.applicationCallbacks = mock(ApplicationCallbacks.class);
+        when(ClientConfig.applicationCallbacks.getApplicationInstance()).thenReturn(app);
+    }
+
+    @After
+    public void tearDown() {
+        cleanupDestFolder(destFolder);
+        assertTrue(destFolder.delete());
+
+        DBWriter.tearDownTests();
+        PodDBAdapter.tearDownTests();
+    }
+
+    private void cleanupDestFolder(File destFolder) {
+        //noinspection ConstantConditions
+        for (File f : destFolder.listFiles()) {
+            assertTrue(f.delete());
+        }
+    }
+
+    @Test
+    public void testPerformAutoCleanupShouldDelete() throws IOException {
+        final int numItems = EPISODE_CACHE_SIZE * 2;
+
+        Feed feed = new Feed("url", null, "title");
+        List<FeedItem> items = new ArrayList<>();
+        feed.setItems(items);
+        List<File> files = new ArrayList<>();
+        populateItems(numItems, feed, items, files, FeedItem.PLAYED, false, false);
+
+        DBTasks.performAutoCleanup(context);
+        for (int i = 0; i < files.size(); i++) {
+            if (i < EPISODE_CACHE_SIZE) {
+                assertTrue(files.get(i).exists());
+            } else {
+                assertFalse(files.get(i).exists());
+            }
+        }
+    }
+
+    @SuppressWarnings("SameParameterValue")
+    void populateItems(final int numItems, Feed feed, List<FeedItem> items,
+                       List<File> files, int itemState, boolean addToQueue,
+                       boolean addToFavorites) throws IOException {
+        for (int i = 0; i < numItems; i++) {
+            Date itemDate = new Date(numItems - i);
+            Date playbackCompletionDate = null;
+            if (itemState == FeedItem.PLAYED) {
+                playbackCompletionDate = itemDate;
+            }
+            FeedItem item = new FeedItem(0, "title", "id", "link", itemDate, itemState, feed);
+
+            File f = new File(destFolder, "file " + i);
+            assertTrue(f.createNewFile());
+            files.add(f);
+            item.setMedia(new FeedMedia(0, item, 1, 0, 1L, "m",
+                    f.getAbsolutePath(), "url", true, playbackCompletionDate, 0, 0));
+            items.add(item);
+        }
+
+        PodDBAdapter adapter = PodDBAdapter.getInstance();
+        adapter.open();
+        adapter.setCompleteFeed(feed);
+        if (addToQueue) {
+            adapter.setQueue(items);
+        }
+        if (addToFavorites) {
+            adapter.setFavorites(items);
+        }
+        adapter.close();
+
+        assertTrue(feed.getId() != 0);
+        for (FeedItem item : items) {
+            assertTrue(item.getId() != 0);
+            //noinspection ConstantConditions
+            assertTrue(item.getMedia().getId() != 0);
+        }
+    }
+
+    @Test
+    public void testPerformAutoCleanupHandleUnplayed() throws IOException {
+        final int numItems = EPISODE_CACHE_SIZE * 2;
+
+        Feed feed = new Feed("url", null, "title");
+        List<FeedItem> items = new ArrayList<>();
+        feed.setItems(items);
+        List<File> files = new ArrayList<>();
+        populateItems(numItems, feed, items, files, FeedItem.UNPLAYED, false, false);
+
+        DBTasks.performAutoCleanup(context);
+        for (File file : files) {
+            assertTrue(file.exists());
+        }
+    }
+
+    @Test
+    public void testPerformAutoCleanupShouldNotDeleteBecauseInQueue() throws IOException {
+        final int numItems = EPISODE_CACHE_SIZE * 2;
+
+        Feed feed = new Feed("url", null, "title");
+        List<FeedItem> items = new ArrayList<>();
+        feed.setItems(items);
+        List<File> files = new ArrayList<>();
+        populateItems(numItems, feed, items, files, FeedItem.PLAYED, true, false);
+
+        DBTasks.performAutoCleanup(context);
+        for (File file : files) {
+            assertTrue(file.exists());
+        }
+    }
+
+    /**
+     * Reproduces a bug where DBTasks.performAutoCleanup(android.content.Context) would use the ID
+     * of the FeedItem in the call to DBWriter.deleteFeedMediaOfItem instead of the ID of the FeedMedia.
+     * This would cause the wrong item to be deleted.
+     */
+    @Test
+    public void testPerformAutoCleanupShouldNotDeleteBecauseInQueue_withFeedsWithNoMedia() throws IOException {
+        // add feed with no enclosures so that item ID != media ID
+        saveFeedlist(1, 10, false);
+
+        // add candidate for performAutoCleanup
+        List<Feed> feeds = saveFeedlist(1, 1, true);
+        FeedMedia m = feeds.get(0).getItems().get(0).getMedia();
+        //noinspection ConstantConditions
+        m.setDownloaded(true);
+        m.setFile_url("file");
+        PodDBAdapter adapter = PodDBAdapter.getInstance();
+        adapter.open();
+        adapter.setMedia(m);
+        adapter.close();
+
+        testPerformAutoCleanupShouldNotDeleteBecauseInQueue();
+    }
+
+    @Test
+    public void testPerformAutoCleanupShouldNotDeleteBecauseFavorite() throws IOException {
+        final int numItems = EPISODE_CACHE_SIZE * 2;
+
+        Feed feed = new Feed("url", null, "title");
+        List<FeedItem> items = new ArrayList<>();
+        feed.setItems(items);
+        List<File> files = new ArrayList<>();
+        populateItems(numItems, feed, items, files, FeedItem.PLAYED, false, true);
+
+        DBTasks.performAutoCleanup(context);
+        for (File file : files) {
+            assertTrue(file.exists());
+        }
+    }
+}
diff --git a/core/src/test/java/de/danoeh/antennapod/core/storage/DbQueueCleanupAlgorithmTest.java b/core/src/test/java/de/danoeh/antennapod/core/storage/DbQueueCleanupAlgorithmTest.java
new file mode 100644
index 000000000..6e53bd20e
--- /dev/null
+++ b/core/src/test/java/de/danoeh/antennapod/core/storage/DbQueueCleanupAlgorithmTest.java
@@ -0,0 +1,52 @@
+package de.danoeh.antennapod.core.storage;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import de.danoeh.antennapod.core.feed.Feed;
+import de.danoeh.antennapod.core.feed.FeedItem;
+import de.danoeh.antennapod.core.preferences.UserPreferences;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Tests that the APQueueCleanupAlgorithm is working correctly.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class DbQueueCleanupAlgorithmTest extends DbCleanupTests {
+
+    public DbQueueCleanupAlgorithmTest() {
+        setCleanupAlgorithm(UserPreferences.EPISODE_CLEANUP_QUEUE);
+    }
+
+    /**
+     * For APQueueCleanupAlgorithm we expect even unplayed episodes to be deleted if needed
+     * if they aren't in the queue.
+     */
+    @Test
+    public void testPerformAutoCleanupHandleUnplayed() throws IOException {
+        final int numItems = EPISODE_CACHE_SIZE * 2;
+
+        Feed feed = new Feed("url", null, "title");
+        List<FeedItem> items = new ArrayList<>();
+        feed.setItems(items);
+        List<File> files = new ArrayList<>();
+        populateItems(numItems, feed, items, files, FeedItem.UNPLAYED, false, false);
+
+        DBTasks.performAutoCleanup(context);
+        for (int i = 0; i < files.size(); i++) {
+            if (i < EPISODE_CACHE_SIZE) {
+                assertTrue(files.get(i).exists());
+            } else {
+                assertFalse(files.get(i).exists());
+            }
+        }
+    }
+}
diff --git a/core/src/test/java/de/danoeh/antennapod/core/storage/DbReaderTest.java b/core/src/test/java/de/danoeh/antennapod/core/storage/DbReaderTest.java
new file mode 100644
index 000000000..212b94743
--- /dev/null
+++ b/core/src/test/java/de/danoeh/antennapod/core/storage/DbReaderTest.java
@@ -0,0 +1,420 @@
+package de.danoeh.antennapod.core.storage;
+
+import android.content.Context;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Random;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import de.danoeh.antennapod.core.feed.Feed;
+import de.danoeh.antennapod.core.feed.FeedItem;
+import de.danoeh.antennapod.core.feed.FeedMedia;
+import de.danoeh.antennapod.core.preferences.UserPreferences;
+import de.danoeh.antennapod.core.util.LongList;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+import static de.danoeh.antennapod.core.storage.DbTestUtils.saveFeedlist;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Test class for DBReader.
+ */
+@SuppressWarnings("ConstantConditions")
+@RunWith(RobolectricTestRunner.class)
+public class DbReaderTest {
+
+    @Before
+    public void setUp() {
+        Context context = InstrumentationRegistry.getInstrumentation().getContext();
+        UserPreferences.init(context);
+
+        PodDBAdapter.init(context);
+        PodDBAdapter.deleteDatabase();
+        PodDBAdapter adapter = PodDBAdapter.getInstance();
+        adapter.open();
+        adapter.close();
+    }
+
+    @After
+    public void tearDown() {
+        PodDBAdapter.tearDownTests();
+        DBWriter.tearDownTests();
+    }
+
+    @Test
+    public void testGetFeedList() {
+        List<Feed> feeds = saveFeedlist(10, 0, false);
+        List<Feed> savedFeeds = DBReader.getFeedList();
+        assertNotNull(savedFeeds);
+        assertEquals(feeds.size(), savedFeeds.size());
+        for (int i = 0; i < feeds.size(); i++) {
+            assertEquals(feeds.get(i).getId(), savedFeeds.get(i).getId());
+        }
+    }
+
+    @Test
+    public void testGetFeedListSortOrder() {
+        PodDBAdapter adapter = PodDBAdapter.getInstance();
+        adapter.open();
+
+        Feed feed1 = new Feed(0, null, "A", "link", "d", null, null, null, "rss", "A", null, "", "", true);
+        Feed feed2 = new Feed(0, null, "b", "link", "d", null, null, null, "rss", "b", null, "", "", true);
+        Feed feed3 = new Feed(0, null, "C", "link", "d", null, null, null, "rss", "C", null, "", "", true);
+        Feed feed4 = new Feed(0, null, "d", "link", "d", null, null, null, "rss", "d", null, "", "", true);
+        adapter.setCompleteFeed(feed1);
+        adapter.setCompleteFeed(feed2);
+        adapter.setCompleteFeed(feed3);
+        adapter.setCompleteFeed(feed4);
+        assertTrue(feed1.getId() != 0);
+        assertTrue(feed2.getId() != 0);
+        assertTrue(feed3.getId() != 0);
+        assertTrue(feed4.getId() != 0);
+
+        adapter.close();
+
+        List<Feed> saved = DBReader.getFeedList();
+        assertNotNull(saved);
+        assertEquals("Wrong size: ", 4, saved.size());
+
+        assertEquals("Wrong id of feed 1: ", feed1.getId(), saved.get(0).getId());
+        assertEquals("Wrong id of feed 2: ", feed2.getId(), saved.get(1).getId());
+        assertEquals("Wrong id of feed 3: ", feed3.getId(), saved.get(2).getId());
+        assertEquals("Wrong id of feed 4: ", feed4.getId(), saved.get(3).getId());
+    }
+
+    @Test
+    public void testFeedListDownloadUrls() {
+        List<Feed> feeds = saveFeedlist(10, 0, false);
+        List<String> urls = DBReader.getFeedListDownloadUrls();
+        assertNotNull(urls);
+        assertEquals(feeds.size(), urls.size());
+        for (int i = 0; i < urls.size(); i++) {
+            assertEquals(urls.get(i), feeds.get(i).getDownload_url());
+        }
+    }
+
+    @Test
+    public void testLoadFeedDataOfFeedItemlist() {
+        final int numFeeds = 10;
+        final int numItems = 1;
+        List<Feed> feeds = saveFeedlist(numFeeds, numItems, false);
+        List<FeedItem> items = new ArrayList<>();
+        for (Feed f : feeds) {
+            for (FeedItem item : f.getItems()) {
+                item.setFeed(null);
+                item.setFeedId(f.getId());
+                items.add(item);
+            }
+        }
+        DBReader.loadAdditionalFeedItemListData(items);
+        for (int i = 0; i < numFeeds; i++) {
+            for (int j = 0; j < numItems; j++) {
+                FeedItem item = feeds.get(i).getItems().get(j);
+                assertNotNull(item.getFeed());
+                assertEquals(feeds.get(i).getId(), item.getFeed().getId());
+                assertEquals(item.getFeed().getId(), item.getFeedId());
+            }
+        }
+    }
+
+    @Test
+    public void testGetFeedItemList() {
+        final int numFeeds = 1;
+        final int numItems = 10;
+        Feed feed = saveFeedlist(numFeeds, numItems, false).get(0);
+        List<FeedItem> items = feed.getItems();
+        feed.setItems(null);
+        List<FeedItem> savedItems = DBReader.getFeedItemList(feed);
+        assertNotNull(savedItems);
+        assertEquals(items.size(), savedItems.size());
+        for (int i = 0; i < savedItems.size(); i++) {
+            assertEquals(savedItems.get(i).getId(), items.get(i).getId());
+        }
+    }
+
+    @SuppressWarnings("SameParameterValue")
+    private List<FeedItem> saveQueue(int numItems) {
+        if (numItems <= 0) {
+            throw new IllegalArgumentException("numItems<=0");
+        }
+        List<Feed> feeds = saveFeedlist(numItems, numItems, false);
+        List<FeedItem> allItems = new ArrayList<>();
+        for (Feed f : feeds) {
+            allItems.addAll(f.getItems());
+        }
+        // take random items from every feed
+        Random random = new Random();
+        List<FeedItem> queue = new ArrayList<>();
+        while (queue.size() < numItems) {
+            int index = random.nextInt(numItems);
+            if (!queue.contains(allItems.get(index))) {
+                queue.add(allItems.get(index));
+            }
+        }
+        PodDBAdapter adapter = PodDBAdapter.getInstance();
+        adapter.open();
+        adapter.setQueue(queue);
+        adapter.close();
+        return queue;
+    }
+
+    @Test
+    public void testGetQueueIdList() {
+        final int numItems = 10;
+        List<FeedItem> queue = saveQueue(numItems);
+        LongList ids = DBReader.getQueueIDList();
+        assertNotNull(ids);
+        assertEquals(ids.size(), queue.size());
+        for (int i = 0; i < queue.size(); i++) {
+            assertTrue(ids.get(i) != 0);
+            assertEquals(ids.get(i), queue.get(i).getId());
+        }
+    }
+
+    @Test
+    public void testGetQueue() {
+        final int numItems = 10;
+        List<FeedItem> queue = saveQueue(numItems);
+        List<FeedItem> savedQueue = DBReader.getQueue();
+        assertNotNull(savedQueue);
+        assertEquals(savedQueue.size(), queue.size());
+        for (int i = 0; i < queue.size(); i++) {
+            assertTrue(savedQueue.get(i).getId() != 0);
+            assertEquals(savedQueue.get(i).getId(), queue.get(i).getId());
+        }
+    }
+
+    @SuppressWarnings("SameParameterValue")
+    private List<FeedItem> saveDownloadedItems(int numItems) {
+        if (numItems <= 0) {
+            throw new IllegalArgumentException("numItems<=0");
+        }
+        List<Feed> feeds = saveFeedlist(numItems, numItems, true);
+        List<FeedItem> items = new ArrayList<>();
+        for (Feed f : feeds) {
+            items.addAll(f.getItems());
+        }
+        List<FeedItem> downloaded = new ArrayList<>();
+        Random random = new Random();
+
+        while (downloaded.size() < numItems) {
+            int i = random.nextInt(numItems);
+            if (!downloaded.contains(items.get(i))) {
+                FeedItem item = items.get(i);
+                item.getMedia().setDownloaded(true);
+                item.getMedia().setFile_url("file" + i);
+                downloaded.add(item);
+            }
+        }
+        PodDBAdapter adapter = PodDBAdapter.getInstance();
+        adapter.open();
+        adapter.setFeedItemlist(downloaded);
+        adapter.close();
+        return downloaded;
+    }
+
+    @Test
+    public void testGetDownloadedItems() {
+        final int numItems = 10;
+        List<FeedItem> downloaded = saveDownloadedItems(numItems);
+        List<FeedItem> downloadedSaved = DBReader.getDownloadedItems();
+        assertNotNull(downloadedSaved);
+        assertEquals(downloaded.size(), downloadedSaved.size());
+        for (FeedItem item : downloadedSaved) {
+            assertNotNull(item.getMedia());
+            assertTrue(item.getMedia().isDownloaded());
+            assertNotNull(item.getMedia().getDownload_url());
+        }
+    }
+
+    @SuppressWarnings("SameParameterValue")
+    private List<FeedItem> saveNewItems(int numItems) {
+        List<Feed> feeds = saveFeedlist(numItems, numItems, true);
+        List<FeedItem> items = new ArrayList<>();
+        for (Feed f : feeds) {
+            items.addAll(f.getItems());
+        }
+        List<FeedItem> newItems = new ArrayList<>();
+        Random random = new Random();
+
+        while (newItems.size() < numItems) {
+            int i = random.nextInt(numItems);
+            if (!newItems.contains(items.get(i))) {
+                FeedItem item = items.get(i);
+                item.setNew();
+                newItems.add(item);
+            }
+        }
+        PodDBAdapter adapter = PodDBAdapter.getInstance();
+        adapter.open();
+        adapter.setFeedItemlist(newItems);
+        adapter.close();
+        return newItems;
+    }
+
+    @Test
+    public void testGetNewItemIds() {
+        final int numItems = 10;
+
+        List<FeedItem> newItems = saveNewItems(numItems);
+        long[] unreadIds = new long[newItems.size()];
+        for (int i = 0; i < newItems.size(); i++) {
+            unreadIds[i] = newItems.get(i).getId();
+        }
+        List<FeedItem> newItemsSaved = DBReader.getNewItemsList(0, Integer.MAX_VALUE);
+        assertNotNull(newItemsSaved);
+        assertEquals(newItemsSaved.size(), newItems.size());
+        for (FeedItem feedItem : newItemsSaved) {
+            long savedId = feedItem.getId();
+            boolean found = false;
+            for (long id : unreadIds) {
+                if (id == savedId) {
+                    found = true;
+                    break;
+                }
+            }
+            assertTrue(found);
+        }
+    }
+
+    @Test
+    public void testGetPlaybackHistory() {
+        final int numItems = (DBReader.PLAYBACK_HISTORY_SIZE + 1) * 2;
+        final int playedItems = DBReader.PLAYBACK_HISTORY_SIZE + 1;
+        final int numReturnedItems = Math.min(playedItems, DBReader.PLAYBACK_HISTORY_SIZE);
+        final int numFeeds = 1;
+
+        Feed feed = DbTestUtils.saveFeedlist(numFeeds, numItems, true).get(0);
+        long[] ids = new long[playedItems];
+
+        PodDBAdapter adapter = PodDBAdapter.getInstance();
+        adapter.open();
+        for (int i = 0; i < playedItems; i++) {
+            FeedMedia m = feed.getItems().get(i).getMedia();
+            m.setPlaybackCompletionDate(new Date(i + 1));
+            adapter.setFeedMediaPlaybackCompletionDate(m);
+            ids[ids.length - 1 - i] = m.getItem().getId();
+        }
+        adapter.close();
+
+        List<FeedItem> saved = DBReader.getPlaybackHistory();
+        assertNotNull(saved);
+        assertEquals("Wrong size: ", numReturnedItems, saved.size());
+        for (int i = 0; i < numReturnedItems; i++) {
+            FeedItem item = saved.get(i);
+            assertNotNull(item.getMedia().getPlaybackCompletionDate());
+            assertEquals("Wrong sort order: ", item.getId(), ids[i]);
+        }
+    }
+
+    @Test
+    public void testGetNavDrawerDataQueueEmptyNoUnreadItems() {
+        final int numFeeds = 10;
+        final int numItems = 10;
+        DbTestUtils.saveFeedlist(numFeeds, numItems, true);
+        DBReader.NavDrawerData navDrawerData = DBReader.getNavDrawerData();
+        assertEquals(numFeeds, navDrawerData.feeds.size());
+        assertEquals(0, navDrawerData.numNewItems);
+        assertEquals(0, navDrawerData.queueSize);
+    }
+
+    @Test
+    public void testGetNavDrawerDataQueueNotEmptyWithUnreadItems() {
+        final int numFeeds = 10;
+        final int numItems = 10;
+        final int numQueue = 1;
+        final int numNew = 2;
+        List<Feed> feeds = DbTestUtils.saveFeedlist(numFeeds, numItems, true);
+        PodDBAdapter adapter = PodDBAdapter.getInstance();
+        adapter.open();
+        for (int i = 0; i < numNew; i++) {
+            FeedItem item = feeds.get(0).getItems().get(i);
+            item.setNew();
+            adapter.setSingleFeedItem(item);
+        }
+        List<FeedItem> queue = new ArrayList<>();
+        for (int i = 0; i < numQueue; i++) {
+            FeedItem item = feeds.get(1).getItems().get(i);
+            queue.add(item);
+        }
+        adapter.setQueue(queue);
+
+        adapter.close();
+
+        DBReader.NavDrawerData navDrawerData = DBReader.getNavDrawerData();
+        assertEquals(numFeeds, navDrawerData.feeds.size());
+        assertEquals(numNew, navDrawerData.numNewItems);
+        assertEquals(numQueue, navDrawerData.queueSize);
+    }
+
+    @Test
+    public void testGetFeedItemlistCheckChaptersFalse() {
+        List<Feed> feeds = DbTestUtils.saveFeedlist(10, 10, false, false, 0);
+        for (Feed feed : feeds) {
+            for (FeedItem item : feed.getItems()) {
+                assertFalse(item.hasChapters());
+            }
+        }
+    }
+
+    @Test
+    public void testGetFeedItemlistCheckChaptersTrue() {
+        List<Feed> feeds = saveFeedlist(10, 10, false, true, 10);
+        for (Feed feed : feeds) {
+            for (FeedItem item : feed.getItems()) {
+                assertTrue(item.hasChapters());
+            }
+        }
+    }
+
+    @Test
+    public void testLoadChaptersOfFeedItemNoChapters() {
+        List<Feed> feeds = saveFeedlist(1, 3, false, false, 0);
+        saveFeedlist(1, 3, false, true, 3);
+        for (Feed feed : feeds) {
+            for (FeedItem item : feed.getItems()) {
+                assertFalse(item.hasChapters());
+                item.setChapters(DBReader.loadChaptersOfFeedItem(item));
+                assertFalse(item.hasChapters());
+                assertNull(item.getChapters());
+            }
+        }
+    }
+
+    @Test
+    public void testLoadChaptersOfFeedItemWithChapters() {
+        final int numChapters = 3;
+        DbTestUtils.saveFeedlist(1, 3, false, false, 0);
+        List<Feed> feeds = saveFeedlist(1, 3, false, true, numChapters);
+        for (Feed feed : feeds) {
+            for (FeedItem item : feed.getItems()) {
+                assertTrue(item.hasChapters());
+                item.setChapters(DBReader.loadChaptersOfFeedItem(item));
+                assertTrue(item.hasChapters());
+                assertNotNull(item.getChapters());
+                assertEquals(numChapters, item.getChapters().size());
+            }
+        }
+    }
+
+    @Test
+    public void testGetItemWithChapters() {
+        final int numChapters = 3;
+        List<Feed> feeds = saveFeedlist(1, 1, false, true, numChapters);
+        FeedItem item1 = feeds.get(0).getItems().get(0);
+        FeedItem item2 = DBReader.getFeedItem(item1.getId());
+        item2.setChapters(DBReader.loadChaptersOfFeedItem(item2));
+        assertTrue(item2.hasChapters());
+        assertEquals(item1.getChapters(), item2.getChapters());
+    }
+}
diff --git a/core/src/test/java/de/danoeh/antennapod/core/storage/DbTestUtils.java b/core/src/test/java/de/danoeh/antennapod/core/storage/DbTestUtils.java
new file mode 100644
index 000000000..400ddda36
--- /dev/null
+++ b/core/src/test/java/de/danoeh/antennapod/core/storage/DbTestUtils.java
@@ -0,0 +1,77 @@
+package de.danoeh.antennapod.core.storage;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+
+import de.danoeh.antennapod.core.feed.Chapter;
+import de.danoeh.antennapod.core.feed.Feed;
+import de.danoeh.antennapod.core.feed.FeedItem;
+import de.danoeh.antennapod.core.feed.FeedMedia;
+import de.danoeh.antennapod.core.feed.SimpleChapter;
+import de.danoeh.antennapod.core.util.comparator.FeedItemPubdateComparator;
+
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Utility methods for DB* tests.
+ */
+abstract class DbTestUtils {
+
+    /**
+     * Use this method when tests don't involve chapters.
+     */
+    public static List<Feed> saveFeedlist(int numFeeds, int numItems, boolean withMedia) {
+        return saveFeedlist(numFeeds, numItems, withMedia, false, 0);
+    }
+
+    /**
+     * Use this method when tests involve chapters.
+     */
+    public static List<Feed> saveFeedlist(int numFeeds, int numItems, boolean withMedia,
+                                          boolean withChapters, int numChapters) {
+        if (numFeeds <= 0) {
+            throw new IllegalArgumentException("numFeeds<=0");
+        }
+        if (numItems < 0) {
+            throw new IllegalArgumentException("numItems<0");
+        }
+
+        List<Feed> feeds = new ArrayList<>();
+        PodDBAdapter adapter = PodDBAdapter.getInstance();
+        adapter.open();
+        for (int i = 0; i < numFeeds; i++) {
+            Feed f = new Feed(0, null, "feed " + i, "link" + i, "descr", null, null,
+                    null, null, "id" + i, null, null, "url" + i, false);
+            f.setItems(new ArrayList<>());
+            for (int j = 0; j < numItems; j++) {
+                FeedItem item = new FeedItem(0, "item " + j, "id" + j, "link" + j, new Date(),
+                        FeedItem.PLAYED, f, withChapters);
+                if (withMedia) {
+                    FeedMedia media = new FeedMedia(item, "url" + j, 1, "audio/mp3");
+                    item.setMedia(media);
+                }
+                if (withChapters) {
+                    List<Chapter> chapters = new ArrayList<>();
+                    item.setChapters(chapters);
+                    for (int k = 0; k < numChapters; k++) {
+                        chapters.add(new SimpleChapter(k, "item " + j + " chapter " + k,
+                                "http://example.com", "http://example.com/image.png"));
+                    }
+                }
+                f.getItems().add(item);
+            }
+            Collections.sort(f.getItems(), new FeedItemPubdateComparator());
+            adapter.setCompleteFeed(f);
+            assertTrue(f.getId() != 0);
+            for (FeedItem item : f.getItems()) {
+                assertTrue(item.getId() != 0);
+            }
+            feeds.add(f);
+        }
+        adapter.close();
+
+        return feeds;
+    }
+}