diff options
Diffstat (limited to 'tests/unit/src/com/android/tv/recommendation/RoutineWatchEvaluatorTest.java')
| -rw-r--r-- | tests/unit/src/com/android/tv/recommendation/RoutineWatchEvaluatorTest.java | 205 |
1 files changed, 205 insertions, 0 deletions
diff --git a/tests/unit/src/com/android/tv/recommendation/RoutineWatchEvaluatorTest.java b/tests/unit/src/com/android/tv/recommendation/RoutineWatchEvaluatorTest.java new file mode 100644 index 00000000..e3c92859 --- /dev/null +++ b/tests/unit/src/com/android/tv/recommendation/RoutineWatchEvaluatorTest.java @@ -0,0 +1,205 @@ +/* + * 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.recommendation; + +import android.test.MoreAsserts; + +import com.android.tv.data.Program; +import com.android.tv.recommendation.RoutineWatchEvaluator.ProgramTime; + +import java.util.Calendar; +import java.util.List; +import java.util.concurrent.TimeUnit; + +public class RoutineWatchEvaluatorTest extends EvaluatorTestCase<RoutineWatchEvaluator> { + + public RoutineWatchEvaluator createEvaluator() { + return new RoutineWatchEvaluator(); + } + + public void testSplitTextToWords() { + assertSplitTextToWords(""); + assertSplitTextToWords("Google", "Google"); + assertSplitTextToWords("The Big Bang Theory", "The", "Big", "Bang", "Theory"); + assertSplitTextToWords("Hello, world!", "Hello", "world"); + assertSplitTextToWords("Adam's Rib", "Adam's", "Rib"); + assertSplitTextToWords("G.I. Joe", "G.I", "Joe"); + assertSplitTextToWords("A.I.", "A.I"); + } + + public void testCalculateMaximumMatchedWordSequenceLength() { + assertMaximumMatchedWordSequenceLength(0, "", "Google"); + assertMaximumMatchedWordSequenceLength(2, "The Big Bang Theory", "Big Bang"); + assertMaximumMatchedWordSequenceLength(2, "The Big Bang Theory", "Theory Of Big Bang"); + assertMaximumMatchedWordSequenceLength(4, "The Big Bang Theory", "The Big Bang Theory"); + assertMaximumMatchedWordSequenceLength(1, "Modern Family", "Family Guy"); + assertMaximumMatchedWordSequenceLength(1, "The Simpsons", "The Walking Dead"); + assertMaximumMatchedWordSequenceLength(3, "Game Of Thrones 1", "Game Of Thrones 6"); + assertMaximumMatchedWordSequenceLength(0, "Dexter", "Friends"); + } + + public void testProgramTime_createFromProgram() { + Calendar time = Calendar.getInstance(); + int todayDayOfWeek = time.get(Calendar.DAY_OF_WEEK); + // Value of DayOfWeek is between 1 and 7 (inclusive). + int tomorrowDayOfWeek = (todayDayOfWeek % 7) + 1; + + // Today 00:00 - 01:00. + ProgramTime programTimeToday0000_0100 = ProgramTime.createFromProgram( + createDummyProgram(todayAtHourMin(0, 0), TimeUnit.HOURS.toMillis(1))); + assertProgramTime(todayDayOfWeek, hourMinuteToSec(0, 0), hourMinuteToSec(1, 0), + programTimeToday0000_0100); + + // Today 23:30 - 24:30. + ProgramTime programTimeToday2330_2430 = ProgramTime.createFromProgram( + createDummyProgram(todayAtHourMin(23, 30), TimeUnit.HOURS.toMillis(1))); + assertProgramTime(todayDayOfWeek, hourMinuteToSec(23, 30), hourMinuteToSec(24, 30), + programTimeToday2330_2430); + + // Tomorrow 00:00 - 01:00. + ProgramTime programTimeTomorrow0000_0100 = ProgramTime.createFromProgram( + createDummyProgram(tomorrowAtHourMin(0, 0), TimeUnit.HOURS.toMillis(1))); + assertProgramTime(tomorrowDayOfWeek, hourMinuteToSec(0, 0), hourMinuteToSec(1, 0), + programTimeTomorrow0000_0100); + + // Tomorrow 23:30 - 24:30. + ProgramTime programTimeTomorrow2330_2430 = ProgramTime.createFromProgram( + createDummyProgram(tomorrowAtHourMin(23, 30), TimeUnit.HOURS.toMillis(1))); + assertProgramTime(tomorrowDayOfWeek, hourMinuteToSec(23, 30), hourMinuteToSec(24, 30), + programTimeTomorrow2330_2430); + + // Today 18:00 - Tomorrow 12:00. + ProgramTime programTimeToday1800_3600 = ProgramTime.createFromProgram( + createDummyProgram(todayAtHourMin(18, 0), TimeUnit.HOURS.toMillis(18))); + // Maximum duration of ProgramTime is 12 hours. + // So, this program looks like it ends at Tomorrow 06:00 (30:00). + assertProgramTime(todayDayOfWeek, hourMinuteToSec(18, 0), hourMinuteToSec(30, 0), + programTimeToday1800_3600); + } + + public void testCalculateOverlappedIntervalScore() { + // Today 21:00 - 24:00. + ProgramTime programTimeToday2100_2400 = ProgramTime.createFromProgram( + createDummyProgram(todayAtHourMin(21, 0), TimeUnit.HOURS.toMillis(3))); + // Today 22:00 - 01:00. + ProgramTime programTimeToday2200_0100 = ProgramTime.createFromProgram( + createDummyProgram(todayAtHourMin(22, 0), TimeUnit.HOURS.toMillis(3))); + // Tomorrow 00:00 - 03:00. + ProgramTime programTimeTomorrow0000_0300 = ProgramTime.createFromProgram( + createDummyProgram(tomorrowAtHourMin(0, 0), TimeUnit.HOURS.toMillis(3))); + // Tomorrow 20:00 - Tomorrow 23:00. + ProgramTime programTimeTomorrow2000_2300 = ProgramTime.createFromProgram( + createDummyProgram(tomorrowAtHourMin(20, 0), TimeUnit.HOURS.toMillis(3))); + + // 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); + } + + public void testGetTimeOfDayInSec() { + // Time was set as 00:00:00. So, getTimeOfDay must returns 0 (= 0 * 60 * 60 + 0 * 60 + 0). + assertEquals("TimeOfDayInSec", hourMinuteToSec(0, 0), + RoutineWatchEvaluator.getTimeOfDayInSec(todayAtHourMin(0, 0))); + + // Time was set as 23:59:59. So, getTimeOfDay must returns 23 * 60 + 60 + 59 * 60 + 59. + assertEquals("TimeOfDayInSec", hourMinuteSecondToSec(23, 59, 59), + RoutineWatchEvaluator.getTimeOfDayInSec(todayAtHourMinSec(23, 59, 59))); + } + + private void assertSplitTextToWords(String text, String... words) { + List<String> wordList = RoutineWatchEvaluator.splitTextToWords(text); + MoreAsserts.assertContentsInOrder(wordList, words); + } + + private void assertMaximumMatchedWordSequenceLength(int expectedLength, + String text1, String text2) { + List<String> wordList1 = RoutineWatchEvaluator.splitTextToWords(text1); + List<String> wordList2 = RoutineWatchEvaluator.splitTextToWords(text2); + assertEquals("MaximumMatchedWordSequenceLength", expectedLength, + mEvaluator.calculateMaximumMatchedWordSequenceLength(wordList1, wordList2)); + assertEquals("MaximumMatchedWordSequenceLength", expectedLength, + mEvaluator.calculateMaximumMatchedWordSequenceLength(wordList2, wordList1)); + } + + 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); + } + + private void assertOverlappedIntervalScore(int expectedSeconds, boolean overlappedOnSameDay, + ProgramTime t1, ProgramTime t2) { + double score = (double) expectedSeconds; + if (!overlappedOnSameDay) { + 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)); + } + + private int hourMinuteToSec(int hour, int minute) { + return hourMinuteSecondToSec(hour, minute, 0); + } + + private int hourMinuteSecondToSec(int hour, int minute, int second) { + return hour * 60 * 60 + minute * 60 + second; + } + + private Calendar todayAtHourMin(int hour, int minute) { + return todayAtHourMinSec(hour, minute, 0); + } + + private Calendar todayAtHourMinSec(int hour, int minute, int second) { + Calendar time = Calendar.getInstance(); + time.set(Calendar.HOUR_OF_DAY, hour); + time.set(Calendar.MINUTE, minute); + time.set(Calendar.SECOND, second); + return time; + } + + private Calendar tomorrowAtHourMin(int hour, int minute) { + Calendar time = todayAtHourMin(hour, minute); + time.add(Calendar.DATE, 1); + return time; + } + + private Program createDummyProgram(Calendar startTime, long programDurationMs) { + long startTimeMs = startTime.getTimeInMillis(); + + return new Program.Builder() + .setStartTimeUtcMillis(startTimeMs) + .setEndTimeUtcMillis(startTimeMs + programDurationMs) + .build(); + } +} |