tests/unit/src/com/android/tv/recommendation/RoutineWatchEvaluatorTest.java - platform/packages/apps/TV - Git at Google

 /*
  * 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 static org.junit.Assert.assertEquals;

 import android.support.test.filters.SmallTest;
 import android.test.MoreAsserts;

 import com.android.tv.data.Program;
 import com.android.tv.recommendation.RoutineWatchEvaluator.ProgramTime;

 import org.junit.Test;

 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() {
         return new RoutineWatchEvaluator();
     }

     @Test
     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");
     }

     @Test
     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");
     }

     @Test
     public void testCalculateTitleMatchScore_empty() {
         assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("", ""));
         assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("foo", ""));
         assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("", "foo"));
     }

     @Test
     public void testCalculateTitleMatchScore_spaces() {
         assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(" ", " "));
         assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("foo", " "));
         assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(" ", "foo"));
     }


     @Test
     public void testCalculateTitleMatchScore_null() {
         assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(null, null));
         assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("foo", null));
         assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(null, "foo"));
     }

     @Test
     public void testCalculateTitleMatchScore_longerMatchIsBetter() {
         String base = "foo bar baz";
         assertInOrder(
                 score(base, ""),
                 score(base, "bar"),
                 score(base, "foo bar"),
                 score(base, "foo bar baz"));
     }

     @Test
     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);
     }

     @Test
     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);
     }

     @Test
     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,
                 RoutineWatchEvaluator.calculateMaximumMatchedWordSequenceLength(
                         wordList1, wordList2));
         assertEquals("MaximumMatchedWordSequenceLength", expectedLength,
                 RoutineWatchEvaluator.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 = expectedSeconds;
         if (!overlappedOnSameDay) {
             score *= RoutineWatchEvaluator.MULTIPLIER_FOR_UNMATCHED_DAY_OF_WEEK;
         }
         // Two tests for testing commutative law.
         assertEqualScores("OverlappedIntervalScore", score,
                 RoutineWatchEvaluator.calculateOverlappedIntervalScore(t1, t2));
         assertEqualScores("OverlappedIntervalScore", score,
                 RoutineWatchEvaluator.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();
     }

     private static <T> void assertInOrder(T... items) {
         TreeSet<T> copy = new TreeSet<>(Arrays.asList(items));
         MoreAsserts.assertContentsInOrder(copy, items);
     }
 }
	/*
	* 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 static org.junit.Assert.assertEquals;

	import android.support.test.filters.SmallTest;
	import android.test.MoreAsserts;

	import com.android.tv.data.Program;
	import com.android.tv.recommendation.RoutineWatchEvaluator.ProgramTime;

	import org.junit.Test;

	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() {
	return new RoutineWatchEvaluator();
	}

	@Test
	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");
	}

	@Test
	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");
	}

	@Test
	public void testCalculateTitleMatchScore_empty() {
	assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("", ""));
	assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("foo", ""));
	assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("", "foo"));
	}

	@Test
	public void testCalculateTitleMatchScore_spaces() {
	assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(" ", " "));
	assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("foo", " "));
	assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(" ", "foo"));
	}


	@Test
	public void testCalculateTitleMatchScore_null() {
	assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(null, null));
	assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore("foo", null));
	assertEqualScores(0.0, RoutineWatchEvaluator.calculateTitleMatchScore(null, "foo"));
	}

	@Test
	public void testCalculateTitleMatchScore_longerMatchIsBetter() {
	String base = "foo bar baz";
	assertInOrder(
	score(base, ""),
	score(base, "bar"),
	score(base, "foo bar"),
	score(base, "foo bar baz"));
	}

	@Test
	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);
	}

	@Test
	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);
	}

	@Test
	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,
	RoutineWatchEvaluator.calculateMaximumMatchedWordSequenceLength(
	wordList1, wordList2));
	assertEquals("MaximumMatchedWordSequenceLength", expectedLength,
	RoutineWatchEvaluator.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 = expectedSeconds;
	if (!overlappedOnSameDay) {
	score *= RoutineWatchEvaluator.MULTIPLIER_FOR_UNMATCHED_DAY_OF_WEEK;
	}
	// Two tests for testing commutative law.
	assertEqualScores("OverlappedIntervalScore", score,
	RoutineWatchEvaluator.calculateOverlappedIntervalScore(t1, t2));
	assertEqualScores("OverlappedIntervalScore", score,
	RoutineWatchEvaluator.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();
	}

	private static <T> void assertInOrder(T... items) {
	TreeSet<T> copy = new TreeSet<>(Arrays.asList(items));
	MoreAsserts.assertContentsInOrder(copy, items);
	}
	}