DO NOT MERGE Sync to joey ub-tv-dev at e7fbaa585b1eb7afec05f05032d2e8d99fb595d4

Bug: 28469968
Change-Id: I74e368f5f58b433755932b806a90178e37bea7f9

16 files changed, 663 insertions, 206 deletions

diff --git a/tests/unit/Android.mk b/tests/unit/Android.mk
index 55ee5276..3808cdc2 100644
--- a/tests/unit/Android.mk
+++ b/tests/unit/Android.mk
@@ -17,5 +17,6 @@ LOCAL_PACKAGE_NAME := TVUnitTests
 LOCAL_INSTRUMENTATION_FOR := LiveTv
 
 LOCAL_SDK_VERSION := current
+LOCAL_MIN_SDK_VERSION := 23  # M
 
 include $(BUILD_PACKAGE)
diff --git a/tests/unit/src/com/android/tv/common/ui/setup/leanback/PagingIndicatorTest.java b/tests/unit/src/com/android/tv/common/ui/setup/leanback/PagingIndicatorTest.java
deleted file mode 100644
index b342de66..00000000
--- a/tests/unit/src/com/android/tv/common/ui/setup/leanback/PagingIndicatorTest.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.android.tv.common.ui.setup.leanback;
-
-import android.test.AndroidTestCase;
-import android.test.suitebuilder.annotation.SmallTest;
-
-import com.android.tv.testing.Utils;
-
-/**
- * Tests for {@link PagingIndicator}.
- */
-@SmallTest
-public class PagingIndicatorTest extends AndroidTestCase {
-    private PagingIndicator mIndicator;
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        Utils.runOnMainSync(new Runnable() {
-            @Override
-            public void run() {
-                mIndicator = new PagingIndicator(getContext());
-            }
-        });
-    }
-
-    public void testDotPosition() {
-        mIndicator.setPageCount(3);
-        assertDotPosition();
-        mIndicator.setPageCount(6);
-        assertDotPosition();
-        mIndicator.setPageCount(9);
-        assertDotPosition();
-    }
-
-    private void assertDotPosition() {
-        assertSymmetry();
-        assertDistance();
-    }
-
-    private void assertSymmetry() {
-        int pageCount = mIndicator.getPageCount();
-        int mid = pageCount / 2;
-        int[] selectedX = mIndicator.getDotSelectedX();
-        int sum = selectedX[0] + selectedX[pageCount - 1];
-        for (int i = 1; i <= mid; ++i) {
-            assertEquals("Selected dots are not symmetric", sum,
-                    selectedX[i] + selectedX[pageCount - i - 1]);
-        }
-        int[] leftX = mIndicator.getDotSelectedLeftX();
-        int[] rightX = mIndicator.getDotSelectedRightX();
-        sum = leftX[0] + rightX[pageCount - 1];
-        for (int i = 1; i < pageCount - 1; ++i) {
-            assertEquals("Deselected dots are not symmetric", sum,
-                    leftX[i] + rightX[pageCount - i - 1]);
-        }
-    }
-
-    private void assertDistance() {
-        int pageCount = mIndicator.getPageCount();
-        int[] selectedX = mIndicator.getDotSelectedX();
-        int[] leftX = mIndicator.getDotSelectedLeftX();
-        int[] rightX = mIndicator.getDotSelectedRightX();
-        int distance = selectedX[1] - selectedX[0];
-        for (int i = 2; i < pageCount; ++i) {
-            assertEquals("Gaps between selected dots are not even", distance,
-                    selectedX[i] - selectedX[i - 1]);
-        }
-        distance = leftX[1] - leftX[0];
-        for (int i = 2; i < pageCount - 1; ++i) {
-            assertEquals("Gaps between left dots are not even", distance,
-                    leftX[i] - leftX[i - 1]);
-        }
-        distance = rightX[2] - rightX[1];
-        for (int i = 3; i < pageCount; ++i) {
-            assertEquals("Gaps between right dots are not even", distance,
-                    rightX[i] - rightX[i - 1]);
-        }
-    }
-}
diff --git a/tests/unit/src/com/android/tv/data/ChannelDataManagerTest.java b/tests/unit/src/com/android/tv/data/ChannelDataManagerTest.java
index 4dc91ce3..574dac8d 100644
--- a/tests/unit/src/com/android/tv/data/ChannelDataManagerTest.java
+++ b/tests/unit/src/com/android/tv/data/ChannelDataManagerTest.java
@@ -206,6 +206,8 @@ public class ChannelDataManagerTest extends AndroidTestCase {
         channelListener.reset();
 
         // Test {@link ChannelDataManager#applyUpdatedValuesToDb}
+        // Disable the update notification to avoid the unwanted call of "onLoadFinished".
+        mContentResolver.mNotifyDisabled = true;
         mChannelDataManager.applyUpdatedValuesToDb();
         restart();
         browsableChannelList = mChannelDataManager.getBrowsableChannelList();
@@ -240,6 +242,8 @@ public class ChannelDataManagerTest extends AndroidTestCase {
         assertFalse(browsableChannelList.contains(channel2));
 
         // Test {@link ChannelDataManager#applyUpdatedValuesToDb}
+        // Disable the update notification to avoid the unwanted call of "onLoadFinished".
+        mContentResolver.mNotifyDisabled = true;
         mChannelDataManager.applyUpdatedValuesToDb();
         restart();
         browsableChannelList = mChannelDataManager.getBrowsableChannelList();
@@ -270,6 +274,8 @@ public class ChannelDataManagerTest extends AndroidTestCase {
         assertTrue(mChannelDataManager.getChannel(channel.getId()).isLocked());
 
         // Test {@link ChannelDataManager#applyUpdatedValuesToDb}.
+        // Disable the update notification to avoid the unwanted call of "onLoadFinished".
+        mContentResolver.mNotifyDisabled = true;
         mChannelDataManager.applyUpdatedValuesToDb();
         restart();
         assertTrue(mChannelDataManager.getChannel(channel.getId()).isLocked());
@@ -343,11 +349,17 @@ public class ChannelDataManagerTest extends AndroidTestCase {
     }
 
     private class FakeContentResolver extends MockContentResolver {
+        boolean mNotifyDisabled;
+
         @Override
         public void notifyChange(Uri uri, ContentObserver observer, boolean syncToNetwork) {
             super.notifyChange(uri, observer, syncToNetwork);
             if (DEBUG) {
-                Log.d(TAG, "onChanged(uri=" + uri + ", observer=" + observer + ")");
+                Log.d(TAG, "onChanged(uri=" + uri + ", observer=" + observer + ") - Notification "
+                        + (mNotifyDisabled ? "disabled" : "enabled"));
+            }
+            if (mNotifyDisabled) {
+                return;
             }
             // Do not call {@link ContentObserver#onChange} directly to run it on the correct
             // thread.
diff --git a/tests/unit/src/com/android/tv/data/GenreItemTest.java b/tests/unit/src/com/android/tv/data/GenreItemTest.java
new file mode 100644
index 00000000..643768f8
--- /dev/null
+++ b/tests/unit/src/com/android/tv/data/GenreItemTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.tv.data;
+
+import android.media.tv.TvContract.Programs.Genres;
+import android.os.Build;
+import android.support.test.filters.SdkSuppress;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+/**
+ * Tests for {@link Channel}.
+ */
+@SmallTest
+public class GenreItemTest extends AndroidTestCase {
+    private static final String INVALID_GENRE = "INVALID GENRE";
+
+    public void testGetLabels() {
+        // Checks if no exception is thrown.
+        GenreItems.getLabels(getContext());
+    }
+
+    public void testGetCanonicalGenre() {
+        int count = GenreItems.getGenreCount();
+        assertNull(GenreItems.getCanonicalGenre(GenreItems.ID_ALL_CHANNELS));
+        for (int i = 1; i < count; ++i) {
+            assertNotNull(GenreItems.getCanonicalGenre(i));
+        }
+    }
+
+    public void testGetId_base() {
+        int count = GenreItems.getGenreCount();
+        assertEquals(GenreItems.ID_ALL_CHANNELS, GenreItems.getId(null));
+        assertEquals(GenreItems.ID_ALL_CHANNELS, GenreItems.getId(INVALID_GENRE));
+        assertInRange(GenreItems.getId(Genres.FAMILY_KIDS), 1, count - 1);
+        assertInRange(GenreItems.getId(Genres.SPORTS), 1, count - 1);
+        assertInRange(GenreItems.getId(Genres.SHOPPING), 1, count - 1);
+        assertInRange(GenreItems.getId(Genres.MOVIES), 1, count - 1);
+        assertInRange(GenreItems.getId(Genres.COMEDY), 1, count - 1);
+        assertInRange(GenreItems.getId(Genres.TRAVEL), 1, count - 1);
+        assertInRange(GenreItems.getId(Genres.DRAMA), 1, count - 1);
+        assertInRange(GenreItems.getId(Genres.EDUCATION), 1, count - 1);
+        assertInRange(GenreItems.getId(Genres.ANIMAL_WILDLIFE), 1, count - 1);
+        assertInRange(GenreItems.getId(Genres.NEWS), 1, count - 1);
+        assertInRange(GenreItems.getId(Genres.GAMING), 1, count - 1);
+    }
+
+    public void testGetId_lmp_mr1() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP_MR1) {
+            assertEquals(GenreItems.ID_ALL_CHANNELS, GenreItems.getId(Genres.ARTS));
+            assertEquals(GenreItems.ID_ALL_CHANNELS, GenreItems.getId(Genres.ENTERTAINMENT));
+            assertEquals(GenreItems.ID_ALL_CHANNELS, GenreItems.getId(Genres.LIFE_STYLE));
+            assertEquals(GenreItems.ID_ALL_CHANNELS, GenreItems.getId(Genres.MUSIC));
+            assertEquals(GenreItems.ID_ALL_CHANNELS, GenreItems.getId(Genres.PREMIER));
+            assertEquals(GenreItems.ID_ALL_CHANNELS, GenreItems.getId(Genres.TECH_SCIENCE));
+        } else {
+            int count = GenreItems.getGenreCount();
+            assertInRange(GenreItems.getId(Genres.ARTS), 1, count - 1);
+            assertInRange(GenreItems.getId(Genres.ENTERTAINMENT), 1, count - 1);
+            assertInRange(GenreItems.getId(Genres.LIFE_STYLE), 1, count - 1);
+            assertInRange(GenreItems.getId(Genres.MUSIC), 1, count - 1);
+            assertInRange(GenreItems.getId(Genres.PREMIER), 1, count - 1);
+            assertInRange(GenreItems.getId(Genres.TECH_SCIENCE), 1, count - 1);
+        }
+    }
+
+    private void assertInRange(int value, int lower, int upper) {
+        assertTrue(value >= lower && value <= upper);
+    }
+}
diff --git a/tests/unit/src/com/android/tv/data/TvInputNewComparatorTest.java b/tests/unit/src/com/android/tv/data/TvInputNewComparatorTest.java
index 0914f804..6b2bc8e5 100644
--- a/tests/unit/src/com/android/tv/data/TvInputNewComparatorTest.java
+++ b/tests/unit/src/com/android/tv/data/TvInputNewComparatorTest.java
@@ -16,10 +16,12 @@
 
 package com.android.tv.data;
 
+import android.annotation.SuppressLint;
 import android.content.pm.ResolveInfo;
 import android.media.tv.TvInputInfo;
 import android.test.AndroidTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
+import android.test.suitebuilder.annotation.Suppress;
 import android.util.Pair;
 
 import com.android.tv.testing.ComparatorTester;
@@ -40,6 +42,7 @@ import java.util.LinkedHashMap;
  */
 @SmallTest
 public class TvInputNewComparatorTest extends AndroidTestCase {
+    @Suppress  // http://b/26903987
     public void testComparator() throws Exception {
         final LinkedHashMap<String, Pair<Boolean, Boolean>> INPUT_ID_TO_NEW_INPUT =
                 new LinkedHashMap<>();
diff --git a/tests/unit/src/com/android/tv/dvr/BaseDvrDataManagerTest.java b/tests/unit/src/com/android/tv/dvr/BaseDvrDataManagerTest.java
new file mode 100644
index 00000000..3df9ab97
--- /dev/null
+++ b/tests/unit/src/com/android/tv/dvr/BaseDvrDataManagerTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.tv.dvr;
+
+import android.support.annotation.NonNull;
+import android.support.test.filters.SmallTest;
+import android.test.AndroidTestCase;
+import android.test.MoreAsserts;
+
+import com.android.tv.testing.FakeClock;
+import com.android.tv.testing.dvr.RecordingTestUtils;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Tests for {@link BaseDvrDataManager} using {@link DvrDataManagerInMemoryImpl}.
+ */
+@SmallTest
+public class BaseDvrDataManagerTest extends AndroidTestCase {
+    private static final int CHANNEL_ID = 273;
+
+    private DvrDataManagerInMemoryImpl mDvrDataManager;
+    private FakeClock mFakeClock;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mFakeClock = FakeClock.createWithCurrentTime();
+        mDvrDataManager = new DvrDataManagerInMemoryImpl(getContext(), mFakeClock);
+    }
+
+    public void testGetNonStartedScheduledRecordings() {
+        ScheduledRecording recording = mDvrDataManager
+                .addScheduledRecordingInternal(createNewScheduledRecordingStartingNow());
+        List<ScheduledRecording> result = mDvrDataManager.getNonStartedScheduledRecordings();
+        MoreAsserts.assertContentsInAnyOrder(result, recording);
+    }
+
+    public void testGetNonStartedScheduledRecordings_past() {
+        mDvrDataManager.addScheduledRecordingInternal(createNewScheduledRecordingStartingNow());
+        mFakeClock.increment(TimeUnit.MINUTES, 6);
+        List<ScheduledRecording> result = mDvrDataManager.getNonStartedScheduledRecordings();
+        MoreAsserts.assertContentsInAnyOrder(result);
+    }
+
+    @NonNull
+    private ScheduledRecording createNewScheduledRecordingStartingNow() {
+        return ScheduledRecording.buildFrom(RecordingTestUtils
+                .createTestRecordingWithIdAndPeriod(
+                        -1,
+                        CHANNEL_ID,
+                        mFakeClock.currentTimeMillis(),
+                        mFakeClock.currentTimeMillis() + TimeUnit.MINUTES.toMillis(5)))
+                .setState(ScheduledRecording.STATE_RECORDING_NOT_STARTED)
+                .build();
+    }
+}
diff --git a/tests/unit/src/com/android/tv/dvr/DvrDataManagerImplTest.java b/tests/unit/src/com/android/tv/dvr/DvrDataManagerImplTest.java
index 204f7cec..a9c5d390 100644
--- a/tests/unit/src/com/android/tv/dvr/DvrDataManagerImplTest.java
+++ b/tests/unit/src/com/android/tv/dvr/DvrDataManagerImplTest.java
@@ -26,36 +26,44 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
- * Tests for {@link DvrDataManagerImplTest}
+ * Tests for {@link DvrDataManagerImpl}
  */
 @SmallTest
 public class DvrDataManagerImplTest extends TestCase {
+    private static final int CHANNEL_ID = 273;
+
     public void testGetNextScheduledStartTimeAfter() throws Exception {
         long id = 1;
-        List<Recording> recordings = new ArrayList<>();
-        assertNextStartTime(recordings, 0L, DvrDataManager.NEXT_START_TIME_NOT_FOUND);
-        recordings.add(RecordingTestUtils.createTestRecordingWithIdAndPeriod(id++, 10L, 20L));
-        assertNextStartTime(recordings, 9L, 10L);
-        assertNextStartTime(recordings, 10L, DvrDataManager.NEXT_START_TIME_NOT_FOUND);
-        recordings.add(RecordingTestUtils.createTestRecordingWithIdAndPeriod(id++, 20L, 30L));
-        assertNextStartTime(recordings, 9L, 10L);
-        assertNextStartTime(recordings, 10L, 20L);
-        assertNextStartTime(recordings, 20L, DvrDataManager.NEXT_START_TIME_NOT_FOUND);
-        recordings.add(RecordingTestUtils.createTestRecordingWithIdAndPeriod(id++, 30L, 40L));
-        assertNextStartTime(recordings, 9L, 10L);
-        assertNextStartTime(recordings, 10L, 20L);
-        assertNextStartTime(recordings, 20L, 30L);
-        assertNextStartTime(recordings, 30L, DvrDataManager.NEXT_START_TIME_NOT_FOUND);
-        recordings.clear();
-        recordings.add(RecordingTestUtils.createTestRecordingWithIdAndPeriod(id++, 10L, 20L));
-        recordings.add(RecordingTestUtils.createTestRecordingWithIdAndPeriod(id++, 10L, 20L));
-        recordings.add(RecordingTestUtils.createTestRecordingWithIdAndPeriod(id++, 10L, 20L));
-        assertNextStartTime(recordings, 9L, 10L);
-        assertNextStartTime(recordings, 10L, DvrDataManager.NEXT_START_TIME_NOT_FOUND);
+        List<ScheduledRecording> scheduledRecordings = new ArrayList<>();
+        assertNextStartTime(scheduledRecordings, 0L, DvrDataManager.NEXT_START_TIME_NOT_FOUND);
+        scheduledRecordings.add(RecordingTestUtils
+                .createTestRecordingWithIdAndPeriod(id++, CHANNEL_ID, 10L, 20L));
+        assertNextStartTime(scheduledRecordings, 9L, 10L);
+        assertNextStartTime(scheduledRecordings, 10L, DvrDataManager.NEXT_START_TIME_NOT_FOUND);
+        scheduledRecordings.add(RecordingTestUtils
+                .createTestRecordingWithIdAndPeriod(id++, CHANNEL_ID, 20L, 30L));
+        assertNextStartTime(scheduledRecordings, 9L, 10L);
+        assertNextStartTime(scheduledRecordings, 10L, 20L);
+        assertNextStartTime(scheduledRecordings, 20L, DvrDataManager.NEXT_START_TIME_NOT_FOUND);
+        scheduledRecordings.add(RecordingTestUtils
+                .createTestRecordingWithIdAndPeriod(id++, CHANNEL_ID, 30L, 40L));
+        assertNextStartTime(scheduledRecordings, 9L, 10L);
+        assertNextStartTime(scheduledRecordings, 10L, 20L);
+        assertNextStartTime(scheduledRecordings, 20L, 30L);
+        assertNextStartTime(scheduledRecordings, 30L, DvrDataManager.NEXT_START_TIME_NOT_FOUND);
+        scheduledRecordings.clear();
+        scheduledRecordings.add(RecordingTestUtils
+                .createTestRecordingWithIdAndPeriod(id++, CHANNEL_ID, 10L, 20L));
+        scheduledRecordings.add(RecordingTestUtils
+                .createTestRecordingWithIdAndPeriod(id++, CHANNEL_ID, 10L, 20L));
+        scheduledRecordings.add(RecordingTestUtils
+                .createTestRecordingWithIdAndPeriod(id++, CHANNEL_ID, 10L, 20L));
+        assertNextStartTime(scheduledRecordings, 9L, 10L);
+        assertNextStartTime(scheduledRecordings, 10L, DvrDataManager.NEXT_START_TIME_NOT_FOUND);
     }
 
-    private void assertNextStartTime(List<Recording> recordings, long startTime, long expected) {
+    private void assertNextStartTime(List<ScheduledRecording> scheduledRecordings, long startTime, long expected) {
         assertEquals("getNextScheduledStartTimeAfter()", expected,
-                DvrDataManagerImpl.getNextStartTimeAfter(recordings, startTime));
+                DvrDataManagerImpl.getNextStartTimeAfter(scheduledRecordings, startTime));
     }
 }
\ No newline at end of file
diff --git a/tests/unit/src/com/android/tv/dvr/DvrRecordingServiceTest.java b/tests/unit/src/com/android/tv/dvr/DvrRecordingServiceTest.java
index 418caa7e..292233a2 100644
--- a/tests/unit/src/com/android/tv/dvr/DvrRecordingServiceTest.java
+++ b/tests/unit/src/com/android/tv/dvr/DvrRecordingServiceTest.java
@@ -19,6 +19,8 @@ package com.android.tv.dvr;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import android.os.Build;
+import android.support.test.filters.SdkSuppress;
 import android.test.ServiceTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
 
@@ -26,6 +28,7 @@ import com.android.tv.ApplicationSingletons;
 import com.android.tv.MockTvApplication;
 import com.android.tv.common.feature.CommonFeatures;
 import com.android.tv.common.feature.TestableFeature;
+import com.android.tv.testing.FakeClock;
 
 import org.mockito.Mock;
 import org.mockito.Mockito;
@@ -35,6 +38,7 @@ import org.mockito.MockitoAnnotations;
  * Tests for {@link DvrRecordingService}.
  */
 @SmallTest
+@SdkSuppress(minSdkVersion = Build.VERSION_CODES.N)
 public class DvrRecordingServiceTest extends ServiceTestCase<DvrRecordingService> {
 
     @Mock Scheduler mMockScheduler;
@@ -42,13 +46,14 @@ public class DvrRecordingServiceTest extends ServiceTestCase<DvrRecordingService
     private final TestableFeature mDvrFeature = CommonFeatures.DVR;
     private DvrDataManagerInMemoryImpl mDataManager;
     private DvrRecordingService mService;
+    private FakeClock mFakeClock = FakeClock.createWithCurrentTime();
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         mDvrFeature.enableForTest();
         MockitoAnnotations.initMocks(this);
-        mDataManager = new DvrDataManagerInMemoryImpl(getContext());
+        mDataManager = new DvrDataManagerInMemoryImpl(getContext(), mFakeClock);
         setApplication(new MockTvApplication(mApplicationSingletons));
         when(mApplicationSingletons.getDvrDataManager()).thenReturn(mDataManager);
         setupService();
diff --git a/tests/unit/src/com/android/tv/dvr/RecordingTaskTest.java b/tests/unit/src/com/android/tv/dvr/RecordingTaskTest.java
index 8e3b4fd4..2fb0228b 100644
--- a/tests/unit/src/com/android/tv/dvr/RecordingTaskTest.java
+++ b/tests/unit/src/com/android/tv/dvr/RecordingTaskTest.java
@@ -16,7 +16,6 @@
 
 package com.android.tv.dvr;
 
-import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyInt;
 import static org.mockito.Matchers.anyLong;
 import static org.mockito.Matchers.argThat;
@@ -26,6 +25,8 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
+import android.media.tv.TvRecordingClient;
+import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
@@ -34,8 +35,8 @@ import android.support.test.filters.SdkSuppress;
 import android.test.AndroidTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
 
-import com.android.tv.common.recording.TvRecording;
 import com.android.tv.data.Channel;
+import com.android.tv.data.Program;
 import com.android.tv.dvr.RecordingTask.State;
 import com.android.tv.testing.FakeClock;
 import com.android.tv.testing.dvr.RecordingTestUtils;
@@ -52,19 +53,18 @@ import java.util.concurrent.TimeUnit;
  * Tests for {@link RecordingTask}.
  */
 @SmallTest
-@SdkSuppress(minSdkVersion = 23)
+@SdkSuppress(minSdkVersion = Build.VERSION_CODES.N)
 public class RecordingTaskTest extends AndroidTestCase {
     private static final long DURATION = TimeUnit.MINUTES.toMillis(30);
     private static final long START_OFFSET = Scheduler.MS_TO_WAKE_BEFORE_START;
+    public static final int CHANNEL_ID = 273;
 
     private FakeClock mFakeClock;
     private DvrDataManagerInMemoryImpl mDataManager;
-    @Mock
-    Handler mMockHandler;
-    @Mock
-    DvrSessionManager mMockSessionManager;
-    @Mock
-    TvRecording.TvRecordingClient mMockTvRecordingClient;
+    @Mock Handler mMockHandler;
+    @Mock DvrManager mDvrManager;
+    @Mock DvrSessionManager mMockSessionManager;
+    @Mock TvRecordingClient mMockTvRecordingClient;
 
     @Override
     protected void setUp() throws Exception {
@@ -74,17 +74,16 @@ public class RecordingTaskTest extends AndroidTestCase {
         }
         MockitoAnnotations.initMocks(this);
         mFakeClock = FakeClock.createWithCurrentTime();
-        mDataManager = new DvrDataManagerInMemoryImpl(getContext());
+        mDataManager = new DvrDataManagerInMemoryImpl(getContext(), mFakeClock);
     }
 
-
     public void testHandle_init() {
-        Recording r = createRecording();
-        RecordingTask task = createRecordingTask(r);
-        Channel channel = r.getChannel();
+        Channel channel = createTestChannel();
+        ScheduledRecording r = createRecording(channel);
+        RecordingTask task = createRecordingTask(r, channel);
         String inputId = channel.getInputId();
         when(mMockSessionManager.canAcquireDvrSession(inputId, channel)).thenReturn(true);
-        when(mMockSessionManager.acquireDvrSession(inputId, channel))
+        when(mMockSessionManager.createTvRecordingClient("tag", task, null))
                 .thenReturn(mMockTvRecordingClient);
         when(mMockHandler.sendEmptyMessageDelayed(anyInt(), anyLong())).thenReturn(true);
 
@@ -94,49 +93,59 @@ public class RecordingTaskTest extends AndroidTestCase {
 
         assertEquals(State.CONNECTION_PENDING, task.getState());
         verify(mMockSessionManager).canAcquireDvrSession(inputId, channel);
-        verify(mMockSessionManager).acquireDvrSession(inputId, channel);
-        verify(mMockTvRecordingClient).connect(eq(inputId), any(TvRecording.ClientCallback.class));
+        verify(mMockSessionManager).createTvRecordingClient("tag", task, null);
+        verify(mMockTvRecordingClient).tune(eq(inputId), eq(channel.getUri()));
 
         verifySendMessageAt(RecordingTask.MESSAGE_START_RECORDING, uptime + delay);
         verifyNoMoreInteractions(mMockHandler, mMockTvRecordingClient, mMockSessionManager);
     }
 
+    private static Channel createTestChannel() {
+        return new Channel.Builder().setId(CHANNEL_ID).setDisplayName("Test Ch " + CHANNEL_ID)
+                .build();
+    }
 
     public void testHandle_init_cannotAcquireSession() {
-        Recording r = createRecording();
-        r = mDataManager.addRecordingInternal(r);
-        RecordingTask task = createRecordingTask(r);
+        Channel channel = createTestChannel();
+        ScheduledRecording r = createRecording(channel);
+        r = mDataManager.addScheduledRecordingInternal(r);
+        RecordingTask task = createRecordingTask(r, channel);
 
-        when(mMockSessionManager.canAcquireDvrSession(r.getChannel().getInputId(), r.getChannel()))
+        when(mMockSessionManager.canAcquireDvrSession(channel.getInputId(), channel))
                 .thenReturn(false);
 
         assertTrue(task.handleMessage(createMessage(RecordingTask.MESSAGE_INIT)));
 
         assertEquals(State.ERROR, task.getState());
         verifySendMessage(Scheduler.HandlerWrapper.MESSAGE_REMOVE);
-        Recording updatedRecording = mDataManager.getRecording(r.getId());
-        assertEquals("status", Recording.STATE_RECORDING_FAILED, updatedRecording.getState());
+        ScheduledRecording updatedScheduledRecording = mDataManager
+                .getScheduledRecording(r.getId());
+        assertEquals("status", ScheduledRecording.STATE_RECORDING_FAILED,
+                updatedScheduledRecording.getState());
     }
 
     public void testOnConnected() {
-        Recording r = createRecording();
-        mDataManager.addRecording(r);
-        RecordingTask task = createRecordingTask(r);
+        Channel channel = createTestChannel();
+        ScheduledRecording r = createRecording(channel);
+        mDataManager.addScheduledRecording(r);
+        RecordingTask task = createRecordingTask(r, channel);
 
-        task.onConnected();
+        task.onTuned(channel.getUri());
 
         assertEquals(State.CONNECTED, task.getState());
     }
 
-    private Recording createRecording() {
+    private ScheduledRecording createRecording(Channel c) {
         long startTime = mFakeClock.currentTimeMillis() + START_OFFSET;
         long endTime = startTime + DURATION;
-        return RecordingTestUtils.createTestRecordingWithPeriod(startTime, endTime);
+        return RecordingTestUtils.createTestRecordingWithPeriod(c.getId(), startTime, endTime);
     }
 
-    private RecordingTask createRecordingTask(Recording r) {
-        RecordingTask recordingTask = new RecordingTask(r, mMockSessionManager, mDataManager,
-                mFakeClock);
+    private RecordingTask createRecordingTask(ScheduledRecording r, Channel channel) {
+        Program p = r.getProgramId() == ScheduledRecording.ID_NOT_SET ? null
+                : new Program.Builder().setId(r.getId()).build();
+        RecordingTask recordingTask = new RecordingTask(r, channel, mDvrManager,
+                mMockSessionManager, mDataManager, mFakeClock);
         recordingTask.setHandler(mMockHandler);
         return recordingTask;
     }
diff --git a/tests/unit/src/com/android/tv/dvr/ScheduledProgramReaperTest.java b/tests/unit/src/com/android/tv/dvr/ScheduledProgramReaperTest.java
new file mode 100644
index 00000000..6210f464
--- /dev/null
+++ b/tests/unit/src/com/android/tv/dvr/ScheduledProgramReaperTest.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.tv.dvr;
+
+import android.test.MoreAsserts;
+
+import com.android.tv.testing.FakeClock;
+import com.android.tv.testing.dvr.RecordingTestUtils;
+
+import junit.framework.TestCase;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Tests for {@link ScheduledProgramReaper}.
+ */
+public class ScheduledProgramReaperTest extends TestCase {
+    public static final int CHANNEL_ID = 273;
+    public static final long DURATION = TimeUnit.HOURS.toMillis(1);
+
+    private ScheduledProgramReaper mReaper;
+    private FakeClock mFakeClock;
+    private DvrDataManagerInMemoryImpl mDvrDataManager;
+    private ScheduledRecording mScheduledRecordingDay1;
+
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mFakeClock = FakeClock.createWithTimeOne();
+        mDvrDataManager = new DvrDataManagerInMemoryImpl(null, mFakeClock);
+        mReaper = new ScheduledProgramReaper(mDvrDataManager, mFakeClock);
+    }
+
+
+    public void testRun_noRecordings() {
+        MoreAsserts.assertContentsInAnyOrder(mDvrDataManager.getAllScheduledRecordings());
+        mReaper.run();
+        MoreAsserts.assertContentsInAnyOrder(mDvrDataManager.getAllScheduledRecordings());
+    }
+
+    public void testRun_oneRecordingsTomorrow() {
+        ScheduledRecording recording = addNewScheduledRecordingForTomorrow();
+        MoreAsserts
+                .assertContentsInAnyOrder(mDvrDataManager.getAllScheduledRecordings(), recording);
+        mReaper.run();
+        MoreAsserts
+                .assertContentsInAnyOrder(mDvrDataManager.getAllScheduledRecordings(), recording);
+    }
+
+    public void testRun_oneRecordingsStarted() {
+        ScheduledRecording recording = addNewScheduledRecordingForTomorrow();
+        MoreAsserts
+                .assertContentsInAnyOrder(mDvrDataManager.getAllScheduledRecordings(), recording);
+        mFakeClock.increment(TimeUnit.DAYS);
+        mReaper.run();
+        MoreAsserts
+                .assertContentsInAnyOrder(mDvrDataManager.getAllScheduledRecordings(), recording);
+    }
+
+    public void testRun_oneRecordingsFinished() {
+        ScheduledRecording recording = addNewScheduledRecordingForTomorrow();
+        MoreAsserts
+                .assertContentsInAnyOrder(mDvrDataManager.getAllScheduledRecordings(), recording);
+        mFakeClock.increment(TimeUnit.DAYS);
+        mFakeClock.increment(TimeUnit.MINUTES, 2);
+        mReaper.run();
+        MoreAsserts
+                .assertContentsInAnyOrder(mDvrDataManager.getAllScheduledRecordings(), recording);
+    }
+
+    public void testRun_oneRecordingsExpired() {
+        ScheduledRecording recording = addNewScheduledRecordingForTomorrow();
+        MoreAsserts
+                .assertContentsInAnyOrder(mDvrDataManager.getAllScheduledRecordings(), recording);
+        mFakeClock.increment(TimeUnit.DAYS, 1 + ScheduledProgramReaper.DAYS);
+        mFakeClock.increment(TimeUnit.MILLISECONDS, DURATION);
+        // After the cutoff and enough so we can see on the clock
+        mFakeClock.increment(TimeUnit.SECONDS, 1);
+
+        mReaper.run();
+        MoreAsserts.assertContentsInAnyOrder(
+                "Recordings after reaper at " + com.android.tv.util.Utils
+                        .toIsoDateTimeString(mFakeClock.currentTimeMillis()),
+                mDvrDataManager.getAllScheduledRecordings());
+    }
+
+    private ScheduledRecording addNewScheduledRecordingForTomorrow() {
+        long startTime = mFakeClock.currentTimeMillis() + TimeUnit.DAYS.toMillis(1);
+        return RecordingTestUtils.addScheduledRecording(mDvrDataManager, CHANNEL_ID, startTime,
+                startTime + DURATION);
+    }
+}
diff --git a/tests/unit/src/com/android/tv/dvr/RecordingTest.java b/tests/unit/src/com/android/tv/dvr/ScheduledRecordingTest.java
index e5ffaa3b..1aee6d33 100644
--- a/tests/unit/src/com/android/tv/dvr/RecordingTest.java
+++ b/tests/unit/src/com/android/tv/dvr/ScheduledRecordingTest.java
@@ -35,12 +35,14 @@ import java.util.Collections;
 import java.util.List;
 
 /**
- * Tests for {@link RecordingTest}
+ * Tests for {@link ScheduledRecordingTest}
  */
 @SmallTest
-public class RecordingTest extends TestCase {
+public class ScheduledRecordingTest extends TestCase {
+    private static final int CHANNEL_ID = 273;
+
     public void testIsOverLapping() throws Exception {
-        Recording r = createTestRecordingWithIdAndPeriod(1, 10L, 20L);
+        ScheduledRecording r = createTestRecordingWithIdAndPeriod(1, CHANNEL_ID, 10L, 20L);
         assertOverLapping(false, 1L, 9L, r);
 
         assertOverLapping(true, 1L, 20L, r);
@@ -57,41 +59,44 @@ public class RecordingTest extends TestCase {
     public void testBuildProgram() {
         Channel c = new Channel.Builder().build();
         Program p = new Program.Builder().build();
-        Recording actual = Recording.builder(c, p).build();
-        assertEquals("type", Recording.TYPE_PROGRAM, actual.getType());
+        ScheduledRecording actual = ScheduledRecording.builder(p).setChannelId(c.getId()).build();
+        assertEquals("type", ScheduledRecording.TYPE_PROGRAM, actual.getType());
     }
 
     public void testBuildTime() {
-        Recording actual = createTestRecordingWithIdAndPeriod(1, 10L, 20L);
-        assertEquals("type", Recording.TYPE_TIMED, actual.getType());
+        ScheduledRecording actual = createTestRecordingWithIdAndPeriod(1, CHANNEL_ID, 10L, 20L);
+        assertEquals("type", ScheduledRecording.TYPE_TIMED, actual.getType());
     }
 
     public void testBuildFrom() {
-        Recording expected = createTestRecordingWithIdAndPeriod(1, 10L, 20L);
-        Recording actual = Recording.buildFrom(expected).build();
+        ScheduledRecording expected = createTestRecordingWithIdAndPeriod(1, CHANNEL_ID, 10L, 20L);
+        ScheduledRecording actual = ScheduledRecording.buildFrom(expected).build();
         RecordingTestUtils.assertRecordingEquals(expected, actual);
     }
 
     public void testBuild_priority() {
-        Recording a = normalizePriority(createTestRecordingWithIdAndPeriod(1, 10L, 20L));
-        Recording b = normalizePriority(createTestRecordingWithIdAndPeriod(2, 10L, 20L));
-        Recording c = normalizePriority(createTestRecordingWithIdAndPeriod(3, 10L, 20L));
+        ScheduledRecording a = normalizePriority(
+                createTestRecordingWithIdAndPeriod(1, CHANNEL_ID, 10L, 20L));
+        ScheduledRecording b = normalizePriority(
+                createTestRecordingWithIdAndPeriod(2, CHANNEL_ID, 10L, 20L));
+        ScheduledRecording c = normalizePriority(
+                createTestRecordingWithIdAndPeriod(3, CHANNEL_ID, 10L, 20L));
 
         // default priority
         MoreAsserts.assertContentsInOrder(sortByPriority(c,b,a), a, b, c);
 
         // make C preferred over B
-        c = Recording.buildFrom(c).setPriority(b.getPriority() - 1).build();
+        c = ScheduledRecording.buildFrom(c).setPriority(b.getPriority() - 1).build();
         MoreAsserts.assertContentsInOrder(sortByPriority(c,b,a), a, c, b);
     }
 
-    public Collection<Recording> sortByPriority(Recording a, Recording b, Recording c) {
-        List<Recording> list = Arrays.asList(a, b, c);
-        Collections.sort(list, Recording.PRIORITY_COMPARATOR);
+    public Collection<ScheduledRecording> sortByPriority(ScheduledRecording a, ScheduledRecording b, ScheduledRecording c) {
+        List<ScheduledRecording> list = Arrays.asList(a, b, c);
+        Collections.sort(list, ScheduledRecording.PRIORITY_COMPARATOR);
         return list;
     }
 
-    private void assertOverLapping(boolean expected, long lower, long upper, Recording r) {
+    private void assertOverLapping(boolean expected, long lower, long upper, ScheduledRecording r) {
         assertEquals("isOverlapping(Range(" + lower + "," + upper + "), recording " + r, expected,
                 r.isOverLapping(new Range<Long>(lower, upper)));
     }
diff --git a/tests/unit/src/com/android/tv/dvr/SchedulerTest.java b/tests/unit/src/com/android/tv/dvr/SchedulerTest.java
index 6748eddb..140d9091 100644
--- a/tests/unit/src/com/android/tv/dvr/SchedulerTest.java
+++ b/tests/unit/src/com/android/tv/dvr/SchedulerTest.java
@@ -24,11 +24,13 @@ import static org.mockito.Mockito.verifyZeroInteractions;
 
 import android.app.AlarmManager;
 import android.app.PendingIntent;
+import android.os.Build;
 import android.os.Looper;
 import android.support.test.filters.SdkSuppress;
 import android.test.AndroidTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
 
+import com.android.tv.data.ChannelDataManager;
 import com.android.tv.testing.FakeClock;
 import com.android.tv.testing.dvr.RecordingTestUtils;
 
@@ -41,22 +43,27 @@ import java.util.concurrent.TimeUnit;
  * Tests for {@link Scheduler}.
  */
 @SmallTest
-@SdkSuppress(minSdkVersion = 23)
+@SdkSuppress(minSdkVersion = Build.VERSION_CODES.N)
 public class SchedulerTest extends AndroidTestCase {
-    private FakeClock mClock;
+    private static final int CHANNEL_ID = 273;
+
+    private FakeClock mFakeClock;
     private DvrDataManagerInMemoryImpl mDataManager;
     private Scheduler mScheduler;
+    @Mock DvrManager mDvrManager;
     @Mock DvrSessionManager mSessionManager;
     @Mock AlarmManager mMockAlarmManager;
+    @Mock
+    ChannelDataManager mChannelDataManager;
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         MockitoAnnotations.initMocks(this);
-        mClock = FakeClock.createWithCurrentTime();
-        mDataManager = new DvrDataManagerInMemoryImpl(getContext());
-        mScheduler = new Scheduler(Looper.myLooper(), mSessionManager, mDataManager, getContext(),
-                mClock, mMockAlarmManager);
+        mFakeClock = FakeClock.createWithCurrentTime();
+        mDataManager = new DvrDataManagerInMemoryImpl(getContext(), mFakeClock);
+        mScheduler = new Scheduler(Looper.myLooper(), mDvrManager, mSessionManager, mDataManager,
+                mChannelDataManager, getContext(), mFakeClock, mMockAlarmManager);
     }
 
     public void testUpdate_none() throws Exception {
@@ -65,11 +72,12 @@ public class SchedulerTest extends AndroidTestCase {
     }
 
     public void testUpdate_nextIn12Hours() throws Exception {
-        long now = mClock.currentTimeMillis();
+        long now = mFakeClock.currentTimeMillis();
         long startTime = now + TimeUnit.HOURS.toMillis(12);
-        Recording r = RecordingTestUtils.createTestRecordingWithPeriod(startTime,
+        ScheduledRecording r = RecordingTestUtils
+                .createTestRecordingWithPeriod(CHANNEL_ID, startTime,
                 startTime + TimeUnit.HOURS.toMillis(1));
-        mDataManager.addRecording(r);
+        mDataManager.addScheduledRecording(r);
         mScheduler.update();
         verify(mMockAlarmManager).set(
                 eq(AlarmManager.RTC_WAKEUP),
@@ -78,10 +86,10 @@ public class SchedulerTest extends AndroidTestCase {
     }
 
     public void testStartsWithin() throws Exception {
-        long now = mClock.currentTimeMillis();
+        long now = mFakeClock.currentTimeMillis();
         long startTime = now + 3;
-        Recording r = RecordingTestUtils
-                .createTestRecordingWithPeriod(startTime, startTime + 100);
+        ScheduledRecording r = RecordingTestUtils
+                .createTestRecordingWithPeriod(273, startTime, startTime + 100);
         assertFalse(mScheduler.startsWithin(r, 2));
         assertTrue(mScheduler.startsWithin(r, 3));
     }
diff --git a/tests/unit/src/com/android/tv/dvr/ui/SortedArrayAdapterTest.java b/tests/unit/src/com/android/tv/dvr/ui/SortedArrayAdapterTest.java
new file mode 100644
index 00000000..5195c57d
--- /dev/null
+++ b/tests/unit/src/com/android/tv/dvr/ui/SortedArrayAdapterTest.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.tv.dvr.ui;
+
+import android.support.test.filters.SmallTest;
+import android.support.v17.leanback.widget.ClassPresenterSelector;
+import android.support.v17.leanback.widget.ObjectAdapter;
+
+import junit.framework.TestCase;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Objects;
+
+/**
+ * Tests for {@link SortedArrayAdapter}.
+ */
+@SmallTest
+public class SortedArrayAdapterTest extends TestCase {
+
+    public static final TestData P1 = TestData.create(1, "one");
+    public static final TestData P2 = TestData.create(2, "before");
+    public static final TestData P3 = TestData.create(3, "other");
+    private TestSortedArrayAdapter mAdapter;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mAdapter = new TestSortedArrayAdapter();
+    }
+
+    public void testContents_empty() {
+        assertEmpty();
+    }
+
+    public void testAdd_one() {
+        mAdapter.add(P1);
+        assertNotEmpty();
+        assertContentsInOrder(mAdapter, P1);
+    }
+
+    public void testAdd_two() {
+        mAdapter.add(P1);
+        mAdapter.add(P2);
+        assertNotEmpty();
+        assertContentsInOrder(mAdapter, P2, P1);
+    }
+
+    public void testAddAll_two() {
+        mAdapter.addAll(Arrays.asList(P1, P2));
+        assertNotEmpty();
+        assertContentsInOrder(mAdapter, P2, P1);
+    }
+
+    public void testRemove() {
+        mAdapter.add(P1);
+        mAdapter.add(P2);
+        assertNotEmpty();
+        assertContentsInOrder(mAdapter, P2, P1);
+        mAdapter.remove(P3);
+        assertContentsInOrder(mAdapter, P2, P1);
+        mAdapter.remove(P2);
+        assertContentsInOrder(mAdapter, P1);
+        mAdapter.remove(P1);
+        assertEmpty();
+    }
+
+    public void testChange_sorting() {
+        TestData p2_changed = TestData.create(2, "z changed");
+        mAdapter.add(P1);
+        mAdapter.add(P2);
+        assertNotEmpty();
+        assertContentsInOrder(mAdapter, P2, P1);
+        mAdapter.change(p2_changed);
+        assertContentsInOrder(mAdapter, P1, p2_changed);
+    }
+
+    public void testChange_new() {
+        mAdapter.change(P1);
+        assertNotEmpty();
+        assertContentsInOrder(mAdapter, P1);
+    }
+
+    private void assertEmpty() {
+        assertEquals("empty", true, mAdapter.isEmpty());
+        assertContentsInOrder(mAdapter, EmptyHolder.EMPTY_HOLDER);
+    }
+
+    private void assertNotEmpty() {
+        assertEquals("empty", false, mAdapter.isEmpty());
+    }
+
+    private static void assertContentsInOrder(ObjectAdapter adapter, Object... contents) {
+        int ex = contents.length;
+        assertEquals("size", ex, adapter.size());
+        for (int i = 0; i < ex; i++) {
+            assertEquals("element " + 1, contents[i], adapter.get(i));
+        }
+    }
+
+    private static class TestData {
+        @Override
+        public String toString() {
+            return "TestData[" + mId + "]{" + mText + '}';
+        }
+
+        static TestData create(long first, String text) {
+            return new TestData(first, text);
+        }
+
+        private final long mId;
+        private final String mText;
+
+        private TestData(long id, String second) {
+            this.mId = id;
+            this.mText = second;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (!(o instanceof TestData)) return false;
+            TestData that = (TestData) o;
+            return mId == that.mId && Objects.equals(mText, that.mText);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(mId, mText);
+        }
+    }
+
+    private static class TestSortedArrayAdapter extends SortedArrayAdapter<TestData> {
+
+        private static final Comparator<TestData> TEXT_COMPARATOR = new Comparator<TestData>() {
+            @Override
+            public int compare(TestData lhs, TestData rhs) {
+                return lhs.mText.compareTo(rhs.mText);
+            }
+        };
+
+        TestSortedArrayAdapter() {
+            super(new ClassPresenterSelector(), TEXT_COMPARATOR);
+        }
+
+        @Override
+        long getId(TestData item) {
+            return item.mId;
+        }
+
+    }
+}
diff --git a/tests/unit/src/com/android/tv/recommendation/RoutineWatchEvaluatorTest.java b/tests/unit/src/com/android/tv/recommendation/RoutineWatchEvaluatorTest.java
index 2511094e..8427b19f 100644
--- a/tests/unit/src/com/android/tv/recommendation/RoutineWatchEvaluatorTest.java
+++ b/tests/unit/src/com/android/tv/recommendation/RoutineWatchEvaluatorTest.java
@@ -22,12 +22,39 @@ import android.test.suitebuilder.annotation.SmallTest;
 import com.android.tv.data.Program;
 import com.android.tv.recommendation.RoutineWatchEvaluator.ProgramTime;
 
+import java.util.Arrays;
 import java.util.Calendar;
 import java.util.List;
+import java.util.TreeSet;
 import java.util.concurrent.TimeUnit;
 
 @SmallTest
 public class RoutineWatchEvaluatorTest extends EvaluatorTestCase<RoutineWatchEvaluator> {
+    private static class ScoredItem implements Comparable<ScoredItem> {
+        private final String mBase;
+        private final String mText;
+        private final double mScore;
+
+        private ScoredItem(String base, String text) {
+            this.mBase = base;
+            this.mText = text;
+            this.mScore = RoutineWatchEvaluator.calculateTitleMatchScore(base, text);
+        }
+
+        @Override
+        public int compareTo(ScoredItem scoredItem) {
+            return Double.compare(mScore, scoredItem.mScore);
+        }
+
+        @Override
+        public String toString() {
+            return mBase + " scored with " + mText + " is " + mScore;
+        }
+    }
+
+    private static ScoredItem score(String t1, String t2) {
+        return new ScoredItem(t1, t2);
+    }
 
     @Override
     public RoutineWatchEvaluator createEvaluator() {
@@ -55,6 +82,34 @@ public class RoutineWatchEvaluatorTest extends EvaluatorTestCase<RoutineWatchEva
         assertMaximumMatchedWordSequenceLength(0, "Dexter", "Friends");
     }
 
+    public void testCalculateTitleMatchScore_empty() {
+        assertEquals(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("", ""));
+        assertEquals(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("foo", ""));
+        assertEquals(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("", "foo"));
+    }
+
+    public void testCalculateTitleMatchScore_spaces() {
+        assertEquals(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(" ", " "));
+        assertEquals(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("foo", " "));
+        assertEquals(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(" ", "foo"));
+    }
+
+
+    public void testCalculateTitleMatchScore_null() {
+        assertEquals(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(null, null));
+        assertEquals(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("foo", null));
+        assertEquals(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(null, "foo"));
+    }
+
+    public void testCalculateTitleMatchScore_longerMatchIsBetter() {
+        String base = "foo bar baz";
+        assertInOrder(
+                score(base, ""),
+                score(base, "bar"),
+                score(base, "foo bar"),
+                score(base, "foo bar baz"));
+    }
+
     public void testProgramTime_createFromProgram() {
         Calendar time = Calendar.getInstance();
         int todayDayOfWeek = time.get(Calendar.DAY_OF_WEEK);
@@ -110,18 +165,18 @@ public class RoutineWatchEvaluatorTest extends EvaluatorTestCase<RoutineWatchEva
 
         // Check intersection time and commutative law in all cases.
         int oneHourInSec = hourMinuteToSec(1, 0);
-        assertOverlappedIntervalScore(2 * oneHourInSec, true,
-                programTimeToday2100_2400, programTimeToday2200_0100);
-        assertOverlappedIntervalScore(0, false,
-                programTimeToday2100_2400, programTimeTomorrow0000_0300);
-        assertOverlappedIntervalScore(2 * oneHourInSec, false,
-                programTimeToday2100_2400, programTimeTomorrow2000_2300);
-        assertOverlappedIntervalScore(oneHourInSec, true,
-                programTimeToday2200_0100, programTimeTomorrow0000_0300);
-        assertOverlappedIntervalScore(oneHourInSec, false,
-                programTimeToday2200_0100, programTimeTomorrow2000_2300);
-        assertOverlappedIntervalScore(0, false,
-                programTimeTomorrow0000_0300, programTimeTomorrow2000_2300);
+        assertOverlappedIntervalScore(2 * oneHourInSec, true, programTimeToday2100_2400,
+                programTimeToday2200_0100);
+        assertOverlappedIntervalScore(0, false, programTimeToday2100_2400,
+                programTimeTomorrow0000_0300);
+        assertOverlappedIntervalScore(2 * oneHourInSec, false, programTimeToday2100_2400,
+                programTimeTomorrow2000_2300);
+        assertOverlappedIntervalScore(oneHourInSec, true, programTimeToday2200_0100,
+                programTimeTomorrow0000_0300);
+        assertOverlappedIntervalScore(oneHourInSec, false, programTimeToday2200_0100,
+                programTimeTomorrow2000_2300);
+        assertOverlappedIntervalScore(0, false, programTimeTomorrow0000_0300,
+                programTimeTomorrow2000_2300);
     }
 
     public void testGetTimeOfDayInSec() {
@@ -139,8 +194,8 @@ public class RoutineWatchEvaluatorTest extends EvaluatorTestCase<RoutineWatchEva
         MoreAsserts.assertContentsInOrder(wordList, words);
     }
 
-    private void assertMaximumMatchedWordSequenceLength(int expectedLength,
-            String text1, String text2) {
+    private void assertMaximumMatchedWordSequenceLength(int expectedLength, String text1,
+            String text2) {
         List<String> wordList1 = RoutineWatchEvaluator.splitTextToWords(text1);
         List<String> wordList2 = RoutineWatchEvaluator.splitTextToWords(text2);
         assertEquals("MaximumMatchedWordSequenceLength", expectedLength,
@@ -152,10 +207,10 @@ public class RoutineWatchEvaluatorTest extends EvaluatorTestCase<RoutineWatchEva
     private void assertProgramTime(int expectedWeekDay, int expectedStartTimeOfDayInSec,
             int expectedEndTimeOfDayInSec, ProgramTime actualProgramTime) {
         assertEquals("Weekday", expectedWeekDay, actualProgramTime.weekDay);
-        assertEquals("StartTimeOfDayInSec",
-                expectedStartTimeOfDayInSec, actualProgramTime.startTimeOfDayInSec);
-        assertEquals("EndTimeOfDayInSec",
-                expectedEndTimeOfDayInSec, actualProgramTime.endTimeOfDayInSec);
+        assertEquals("StartTimeOfDayInSec", expectedStartTimeOfDayInSec,
+                actualProgramTime.startTimeOfDayInSec);
+        assertEquals("EndTimeOfDayInSec", expectedEndTimeOfDayInSec,
+                actualProgramTime.endTimeOfDayInSec);
     }
 
     private void assertOverlappedIntervalScore(int expectedSeconds, boolean overlappedOnSameDay,
@@ -165,10 +220,10 @@ public class RoutineWatchEvaluatorTest extends EvaluatorTestCase<RoutineWatchEva
             score *= RoutineWatchEvaluator.MULTIPLIER_FOR_UNMATCHED_DAY_OF_WEEK;
         }
         // Two tests for testing commutative law.
-        assertEquals("OverlappedIntervalScore",
-                score, mEvaluator.calculateOverlappedIntervalScore(t1, t2));
-        assertEquals("OverlappedIntervalScore",
-                score, mEvaluator.calculateOverlappedIntervalScore(t2, t1));
+        assertEquals("OverlappedIntervalScore", score,
+                mEvaluator.calculateOverlappedIntervalScore(t1, t2));
+        assertEquals("OverlappedIntervalScore", score,
+                mEvaluator.calculateOverlappedIntervalScore(t2, t1));
     }
 
     private int hourMinuteToSec(int hour, int minute) {
@@ -200,9 +255,12 @@ public class RoutineWatchEvaluatorTest extends EvaluatorTestCase<RoutineWatchEva
     private Program createDummyProgram(Calendar startTime, long programDurationMs) {
         long startTimeMs = startTime.getTimeInMillis();
 
-        return new Program.Builder()
-                .setStartTimeUtcMillis(startTimeMs)
-                .setEndTimeUtcMillis(startTimeMs + programDurationMs)
-                .build();
+        return new Program.Builder().setStartTimeUtcMillis(startTimeMs)
+                .setEndTimeUtcMillis(startTimeMs + programDurationMs).build();
+    }
+
+    private static <T> void assertInOrder(T... items) {
+        TreeSet<T> copy = new TreeSet<>(Arrays.asList(items));
+        MoreAsserts.assertContentsInOrder(copy, items);
     }
 }
diff --git a/tests/unit/src/com/android/tv/util/TestUtils.java b/tests/unit/src/com/android/tv/util/TestUtils.java
index 09d32779..f4befaa8 100644
--- a/tests/unit/src/com/android/tv/util/TestUtils.java
+++ b/tests/unit/src/com/android/tv/util/TestUtils.java
@@ -20,6 +20,7 @@ import android.content.pm.ResolveInfo;
 import android.content.pm.ServiceInfo;
 import android.media.tv.TvInputInfo;
 import android.os.Build;
+import android.support.v4.os.BuildCompat;
 
 import java.lang.reflect.Constructor;
 
@@ -34,6 +35,8 @@ public class TestUtils {
         // Note that mockito doesn't support mock/spy on final object.
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
             return createTvInputInfoForLmp(service, id, parentId, type);
+        } else if (BuildCompat.isAtLeastN()) {
+            new RuntimeException("TOOD(dvr): implement");  // http://b/26903987
         }
         return createTvInputInfoForMnc(service, id, parentId, type, isHardwareInput);
     }
@@ -54,6 +57,14 @@ public class TestUtils {
         return constructor.newInstance(service, id, parentId, type, isHardwareInput);
     }
 
+    private static TvInputInfo createTvInputInfoForNpreview(ResolveInfo service, String id,
+            String parentId, int type) throws Exception {
+        Constructor<TvInputInfo> constructor = TvInputInfo.class.getDeclaredConstructor(
+                new Class[]{ResolveInfo.class, String.class, String.class, int.class});
+        constructor.setAccessible(true);
+        return constructor.newInstance(service, id, parentId, type);
+    }
+
     public static ResolveInfo createResolveInfo(String packageName, String name) {
         ResolveInfo resolveInfo = new ResolveInfo();
         resolveInfo.serviceInfo = new ServiceInfo();
diff --git a/tests/unit/src/com/android/tv/util/TvInputManagerHelperTest.java b/tests/unit/src/com/android/tv/util/TvInputManagerHelperTest.java
index 2f06de59..120e23a4 100644
--- a/tests/unit/src/com/android/tv/util/TvInputManagerHelperTest.java
+++ b/tests/unit/src/com/android/tv/util/TvInputManagerHelperTest.java
@@ -20,6 +20,7 @@ import android.content.pm.ResolveInfo;
 import android.media.tv.TvInputInfo;
 import android.test.AndroidTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
+import android.test.suitebuilder.annotation.Suppress;
 
 import com.android.tv.testing.ComparatorTester;
 
@@ -34,6 +35,7 @@ import java.util.LinkedHashMap;
  */
 @SmallTest
 public class TvInputManagerHelperTest extends AndroidTestCase {
+    @Suppress  // http://b/26903987
     public void testComparator() throws Exception {
         final LinkedHashMap<String, Boolean> INPUT_ID_TO_PARTNER_INPUT = new LinkedHashMap<>();
         INPUT_ID_TO_PARTNER_INPUT.put("2_partner_input", true);