1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16
17package com.android.tv.dvr;
18
19import static org.junit.Assert.assertEquals;
20import static org.junit.Assert.fail;
21
22import android.os.Build;
23import android.support.test.filters.SdkSuppress;
24import android.support.test.filters.SmallTest;
25import android.test.MoreAsserts;
26import android.util.Range;
27
28import com.android.tv.dvr.DvrScheduleManager.ConflictInfo;
29import com.android.tv.dvr.data.ScheduledRecording;
30import com.android.tv.testing.dvr.RecordingTestUtils;
31
32import org.junit.Test;
33
34import java.util.ArrayList;
35import java.util.Arrays;
36import java.util.Collections;
37import java.util.List;
38
39/** Tests for {@link DvrScheduleManager} */
40@SmallTest
41@SdkSuppress(minSdkVersion = Build.VERSION_CODES.N)
42public class DvrScheduleManagerTest {
43    private static final String INPUT_ID = "input_id";
44
45    @Test
46    public void testGetConflictingSchedules_emptySchedule() {
47        List<ScheduledRecording> schedules = new ArrayList<>();
48        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 1));
49    }
50
51    @Test
52    public void testGetConflictingSchedules_noConflict() {
53        long priority = 0;
54        long channelId = 0;
55        List<ScheduledRecording> schedules = new ArrayList<>();
56
57        schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
58                ++priority, 0L, 200L));
59        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 1));
60
61        schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
62                ++priority, 0L, 100L));
63        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2));
64
65        schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
66                ++priority, 100L, 200L));
67        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2));
68
69        schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
70                ++priority, 0L, 100L));
71        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 3));
72
73        schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
74                ++priority, 100L, 200L));
75        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 3));
76    }
77
78    @Test
79    public void testGetConflictingSchedules_noTuner() {
80        long priority = 0;
81        long channelId = 0;
82        List<ScheduledRecording> schedules = new ArrayList<>();
83        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 0));
84
85        schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
86                ++priority, 0L, 200L));
87        assertEquals(schedules, DvrScheduleManager.getConflictingSchedules(schedules, 0));
88        schedules.add(0, RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
89                ++priority, 0L, 100L));
90        assertEquals(schedules, DvrScheduleManager.getConflictingSchedules(schedules, 0));
91    }
92
93    @Test
94    public void testGetConflictingSchedules_conflict() {
95        long priority = 0;
96        long channelId = 0;
97        List<ScheduledRecording> schedules = new ArrayList<>();
98
99        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
100                ++channelId, ++priority, 0L, 200L);
101        schedules.add(r1);
102        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 1));
103
104        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
105                ++channelId, ++priority, 0L, 100L);
106        schedules.add(r2);
107        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
108                r1);
109        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2));
110
111        ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
112                ++channelId, ++priority, 100L, 200L);
113        schedules.add(r3);
114        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
115                r1);
116        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2));
117
118        ScheduledRecording r4 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
119                ++channelId, ++priority, 0L, 100L);
120        schedules.add(r4);
121        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
122                r2, r1);
123        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 2),
124                r1);
125        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 3));
126
127        ScheduledRecording r5 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
128                ++channelId, ++priority, 100L, 200L);
129        schedules.add(r5);
130        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
131                r3, r2, r1);
132        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 2),
133                r1);
134        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 3));
135
136        ScheduledRecording r6 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
137                ++channelId, ++priority, 10L, 90L);
138        schedules.add(r6);
139        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
140                r4, r3, r2, r1);
141        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 2),
142                r2, r1);
143        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 3),
144                r1);
145        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 4));
146
147        ScheduledRecording r7 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
148                ++channelId, ++priority, 110L, 190L);
149        schedules.add(r7);
150        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
151                r5, r4, r3, r2, r1);
152        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 2),
153                r3, r2, r1);
154        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 3),
155                r1);
156        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 4));
157
158        ScheduledRecording r8 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
159                ++channelId, ++priority, 50L, 150L);
160        schedules.add(r8);
161        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
162                r7, r6, r5, r4, r3, r2, r1);
163        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 2),
164                r5, r4, r3, r2, r1);
165        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 3),
166                r3, r2, r1);
167        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 4),
168                r1);
169        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 5));
170    }
171
172    @Test
173    public void testGetConflictingSchedules_conflict2() {
174        // The case when there is a long schedule.
175        long priority = 0;
176        long channelId = 0;
177        List<ScheduledRecording> schedules = new ArrayList<>();
178
179        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
180                ++channelId, ++priority, 0L, 1000L);
181        schedules.add(r1);
182        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 1));
183
184        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
185                ++channelId, ++priority, 0L, 100L);
186        schedules.add(r2);
187        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
188                r1);
189        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2));
190
191        ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
192                ++channelId, ++priority, 100L, 200L);
193        schedules.add(r3);
194        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
195                r1);
196        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2));
197    }
198
199    @Test
200    public void testGetConflictingSchedules_reverseOrder() {
201        long priority = 0;
202        long channelId = 0;
203        List<ScheduledRecording> schedules = new ArrayList<>();
204
205        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
206                ++channelId, ++priority, 0L, 200L);
207        schedules.add(0, r1);
208        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 1));
209
210        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
211                ++channelId, ++priority, 0L, 100L);
212        schedules.add(0, r2);
213        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
214                r1);
215        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2));
216
217        ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
218                ++channelId, ++priority, 100L, 200L);
219        schedules.add(0, r3);
220        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
221                r1);
222        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2));
223
224        ScheduledRecording r4 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
225                ++channelId, ++priority, 0L, 100L);
226        schedules.add(0, r4);
227        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
228                r2, r1);
229        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 2),
230                r1);
231        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 3));
232
233        ScheduledRecording r5 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
234                ++channelId, ++priority, 100L, 200L);
235        schedules.add(0, r5);
236        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
237                r3, r2, r1);
238        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 2),
239                r1);
240        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 3));
241
242        ScheduledRecording r6 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
243                ++channelId, ++priority, 10L, 90L);
244        schedules.add(0, r6);
245        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
246                r4, r3, r2, r1);
247        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 2),
248                r2, r1);
249        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 3),
250                r1);
251        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 4));
252
253        ScheduledRecording r7 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
254                ++channelId, ++priority, 110L, 190L);
255        schedules.add(0, r7);
256        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
257                r5, r4, r3, r2, r1);
258        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 2),
259                r3, r2, r1);
260        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 3),
261                r1);
262        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 4));
263
264        ScheduledRecording r8 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
265                ++channelId, ++priority, 50L, 150L);
266        schedules.add(0, r8);
267        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
268                r7, r6, r5, r4, r3, r2, r1);
269        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 2),
270                r5, r4, r3, r2, r1);
271        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 3),
272                r3, r2, r1);
273        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 4),
274                r1);
275        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 5));
276    }
277
278    @Test
279    public void testGetConflictingSchedules_period1() {
280        long priority = 0;
281        long channelId = 0;
282        List<ScheduledRecording> schedules = new ArrayList<>();
283
284        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
285                ++channelId, ++priority, 0L, 200L);
286        schedules.add(r1);
287        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
288                ++channelId, ++priority, 0L, 100L);
289        schedules.add(r2);
290        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1,
291                Collections.singletonList(new Range<>(10L, 20L))), r1);
292        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1,
293                Collections.singletonList(new Range<>(110L, 120L))), r1);
294    }
295
296    @Test
297    public void testGetConflictingSchedules_period2() {
298        long priority = 0;
299        long channelId = 0;
300        List<ScheduledRecording> schedules = new ArrayList<>();
301
302        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
303                ++channelId, ++priority, 0L, 200L);
304        schedules.add(r1);
305        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
306                ++channelId, ++priority, 100L, 200L);
307        schedules.add(r2);
308        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1,
309                Collections.singletonList(new Range<>(10L, 20L))), r1);
310        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1,
311                Collections.singletonList(new Range<>(110L, 120L))), r1);
312    }
313
314    @Test
315    public void testGetConflictingSchedules_period3() {
316        long priority = 0;
317        long channelId = 0;
318        List<ScheduledRecording> schedules = new ArrayList<>();
319
320        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
321                ++channelId, ++priority, 0L, 100L);
322        schedules.add(r1);
323        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
324                ++channelId, ++priority, 100L, 200L);
325        schedules.add(r2);
326        ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
327                ++channelId, ++priority, 0L, 100L);
328        schedules.add(r3);
329        ScheduledRecording r4 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
330                ++channelId, ++priority, 100L, 200L);
331        schedules.add(r4);
332        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1,
333                Collections.singletonList(new Range<>(10L, 20L))), r1);
334        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1,
335                Collections.singletonList(new Range<>(110L, 120L))), r2);
336        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1,
337                Collections.singletonList(new Range<>(50L, 150L))), r2, r1);
338        List<Range<Long>> ranges = new ArrayList<>();
339        ranges.add(new Range<>(10L, 20L));
340        ranges.add(new Range<>(110L, 120L));
341        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1,
342                ranges), r2, r1);
343    }
344
345    @Test
346    public void testGetConflictingSchedules_addSchedules1() {
347        long priority = 0;
348        long channelId = 0;
349        List<ScheduledRecording> schedules = new ArrayList<>();
350
351        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
352                ++channelId, ++priority, 0L, 200L);
353        schedules.add(r1);
354        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
355                ++channelId, ++priority, 0L, 100L);
356        schedules.add(r2);
357        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(
358                Collections.singletonList(
359                        ScheduledRecording.builder(INPUT_ID, ++channelId, 10L, 20L)
360                                .setPriority(++priority).build()),
361                schedules, 1), r2, r1);
362        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(
363                Collections.singletonList(
364                        ScheduledRecording.builder(INPUT_ID, ++channelId, 110L, 120L)
365                                .setPriority(++priority).build()),
366                schedules, 1), r1);
367    }
368
369    @Test
370    public void testGetConflictingSchedules_addSchedules2() {
371        long priority = 0;
372        long channelId = 0;
373        List<ScheduledRecording> schedules = new ArrayList<>();
374
375        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
376                ++channelId, ++priority, 0L, 200L);
377        schedules.add(r1);
378        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
379                ++channelId, ++priority, 100L, 200L);
380        schedules.add(r2);
381        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(
382                Collections.singletonList(
383                        ScheduledRecording.builder(INPUT_ID, ++channelId, 10L, 20L)
384                                .setPriority(++priority).build()),
385                schedules, 1), r1);
386        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(
387                Collections.singletonList(
388                        ScheduledRecording.builder(INPUT_ID, ++channelId, 110L, 120L)
389                                .setPriority(++priority).build()),
390                schedules, 1), r2, r1);
391    }
392
393    @Test
394    public void testGetConflictingSchedules_addLowestPriority() {
395        long priority = 0;
396        long channelId = 0;
397        List<ScheduledRecording> schedules = new ArrayList<>();
398
399        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
400                ++channelId, ++priority, 0L, 400L);
401        schedules.add(r1);
402        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
403                ++channelId, ++priority, 100L, 200L);
404        schedules.add(r2);
405        // Returning r1 even though r1 has the higher priority than the new one. That's because r1
406        // starts at 0 and stops at 100, and the new one will be recorded successfully.
407        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(
408                Collections.singletonList(
409                        ScheduledRecording.builder(INPUT_ID, ++channelId, 200L, 300L)
410                                .setPriority(0).build()),
411                schedules, 1), r1);
412    }
413
414    @Test
415    public void testGetConflictingSchedules_sameChannel() {
416        long priority = 0;
417        long channelId = 1;
418        List<ScheduledRecording> schedules = new ArrayList<>();
419        schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(channelId,
420                ++priority, 0L, 200L));
421        schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(channelId,
422                ++priority, 0L, 200L));
423        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 3));
424    }
425
426    @Test
427    public void testGetConflictingSchedule_startEarlyAndFail() {
428        long priority = 0;
429        long channelId = 0;
430        List<ScheduledRecording> schedules = new ArrayList<>();
431        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
432                ++channelId, ++priority, 200L, 300L);
433        schedules.add(r1);
434        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
435                ++channelId, ++priority, 0L, 400L);
436        schedules.add(r2);
437        ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
438                ++channelId, ++priority, 100L, 200L);
439        schedules.add(r3);
440        // r2 starts recording and fails when r3 starts. r1 is recorded successfully.
441        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
442                r2);
443    }
444
445    @Test
446    public void testGetConflictingSchedule_startLate() {
447        long priority = 0;
448        long channelId = 0;
449        List<ScheduledRecording> schedules = new ArrayList<>();
450        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
451                ++channelId, ++priority, 200L, 400L);
452        schedules.add(r1);
453        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
454                ++channelId, ++priority, 100L, 300L);
455        schedules.add(r2);
456        ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
457                ++channelId, ++priority, 0L, 200L);
458        schedules.add(r3);
459        // r2 and r1 are clipped.
460        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1),
461                r2, r1);
462    }
463
464    @Test
465    public void testGetConflictingSchedulesForTune_canTune() {
466        // Can tune to the recorded channel if tuner count is 1.
467        long priority = 0;
468        long channelId = 1;
469        List<ScheduledRecording> schedules = new ArrayList<>();
470        schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(channelId,
471                ++priority, 0L, 200L));
472        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedulesForTune(INPUT_ID,
473                channelId, 0L, priority + 1, schedules, 1));
474    }
475
476    @Test
477    public void testGetConflictingSchedulesForTune_cannotTune() {
478        // Can't tune to a channel if other channel is recording and tuner count is 1.
479        long priority = 0;
480        long channelId = 1;
481        List<ScheduledRecording> schedules = new ArrayList<>();
482        schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(channelId,
483                ++priority, 0L, 200L));
484        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForTune(
485                INPUT_ID, channelId + 1, 0L, priority + 1, schedules, 1), schedules.get(0));
486    }
487
488    @Test
489    public void testGetConflictingSchedulesForWatching_otherChannels() {
490        // The other channels are to be recorded.
491        long priority = 0;
492        long channelToWatch = 1;
493        long channelId = 1;
494        List<ScheduledRecording> schedules = new ArrayList<>();
495        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
496                ++channelId, ++priority, 0L, 200L);
497        schedules.add(r1);
498        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
499                ++channelId, ++priority, 0L, 200L);
500        schedules.add(r2);
501        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedulesForWatching(
502                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 3));
503        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching(
504                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2), r1);
505    }
506
507    @Test
508    public void testGetConflictingSchedulesForWatching_sameChannel1() {
509        long priority = 0;
510        long channelToWatch = 1;
511        long channelId = 1;
512        List<ScheduledRecording> schedules = new ArrayList<>();
513        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
514                channelToWatch, ++priority, 0L, 200L);
515        schedules.add(r1);
516        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
517                ++channelId, ++priority, 0L, 200L);
518        schedules.add(r2);
519        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedulesForWatching(
520                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2));
521        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching(
522                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1), r2);
523    }
524
525    @Test
526    public void testGetConflictingSchedulesForWatching_sameChannel2() {
527        long priority = 0;
528        long channelToWatch = 1;
529        long channelId = 1;
530        List<ScheduledRecording> schedules = new ArrayList<>();
531        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
532                ++channelId, ++priority, 0L, 200L);
533        schedules.add(r1);
534        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
535                channelToWatch, ++priority, 0L, 200L);
536        schedules.add(r2);
537        MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedulesForWatching(
538                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2));
539        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching(
540                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1), r1);
541    }
542
543    @Test
544    public void testGetConflictingSchedulesForWatching_sameChannelConflict1() {
545        long priority = 0;
546        long channelToWatch = 1;
547        long channelId = 1;
548        List<ScheduledRecording> schedules = new ArrayList<>();
549        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
550                ++channelId, ++priority, 0L, 200L);
551        schedules.add(r1);
552        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
553                channelToWatch, ++priority, 0L, 200L);
554        schedules.add(r2);
555        ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
556                channelToWatch, ++priority, 0L, 200L);
557        schedules.add(r3);
558        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching(
559                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 3), r2);
560        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching(
561                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2), r2);
562        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching(
563                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1), r2, r1);
564    }
565
566    @Test
567    public void testGetConflictingSchedulesForWatching_sameChannelConflict2() {
568        long priority = 0;
569        long channelToWatch = 1;
570        long channelId = 1;
571        List<ScheduledRecording> schedules = new ArrayList<>();
572        ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
573                channelToWatch, ++priority, 0L, 200L);
574        schedules.add(r1);
575        ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
576                channelToWatch, ++priority, 0L, 200L);
577        schedules.add(r2);
578        ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
579                ++channelId, ++priority, 0L, 200L);
580        schedules.add(r3);
581        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching(
582                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 3), r1);
583        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching(
584                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2), r1);
585        MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching(
586                INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1), r3, r1);
587    }
588
589    @Test
590    public void testPartiallyConflictingSchedules() {
591        long priority = 100;
592        long channelId = 0;
593        List<ScheduledRecording> schedules = new ArrayList<>(Arrays.asList(
594                RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
595                        --priority, 0L, 400L),
596                RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
597                        --priority, 0L, 200L),
598                RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
599                        --priority, 200L, 500L),
600                RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
601                        --priority, 400L, 600L),
602                RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
603                        --priority, 700L, 800L),
604                RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
605                        --priority, 600L, 900L),
606                RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
607                        --priority, 800L, 900L),
608                RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
609                        --priority, 800L, 900L),
610                RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
611                        --priority, 750L, 850L),
612                RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
613                        --priority, 300L, 450L),
614                RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId,
615                        --priority, 50L, 900L)
616        ));
617        List<ConflictInfo> conflicts = DvrScheduleManager.getConflictingSchedulesInfo(schedules, 1);
618
619        assertNotInList(schedules.get(0), conflicts);
620        assertFullConflict(schedules.get(1), conflicts);
621        assertPartialConflict(schedules.get(2), conflicts);
622        assertPartialConflict(schedules.get(3), conflicts);
623        assertNotInList(schedules.get(4), conflicts);
624        assertPartialConflict(schedules.get(5), conflicts);
625        assertNotInList(schedules.get(6), conflicts);
626        assertFullConflict(schedules.get(7), conflicts);
627        assertFullConflict(schedules.get(8), conflicts);
628        assertFullConflict(schedules.get(9), conflicts);
629        assertFullConflict(schedules.get(10), conflicts);
630
631        conflicts = DvrScheduleManager.getConflictingSchedulesInfo(schedules, 2);
632
633        assertNotInList(schedules.get(0), conflicts);
634        assertNotInList(schedules.get(1), conflicts);
635        assertNotInList(schedules.get(2), conflicts);
636        assertNotInList(schedules.get(3), conflicts);
637        assertNotInList(schedules.get(4), conflicts);
638        assertNotInList(schedules.get(5), conflicts);
639        assertNotInList(schedules.get(6), conflicts);
640        assertFullConflict(schedules.get(7), conflicts);
641        assertFullConflict(schedules.get(8), conflicts);
642        assertFullConflict(schedules.get(9), conflicts);
643        assertPartialConflict(schedules.get(10), conflicts);
644
645        conflicts = DvrScheduleManager.getConflictingSchedulesInfo(schedules, 3);
646
647        assertNotInList(schedules.get(0), conflicts);
648        assertNotInList(schedules.get(1), conflicts);
649        assertNotInList(schedules.get(2), conflicts);
650        assertNotInList(schedules.get(3), conflicts);
651        assertNotInList(schedules.get(4), conflicts);
652        assertNotInList(schedules.get(5), conflicts);
653        assertNotInList(schedules.get(6), conflicts);
654        assertNotInList(schedules.get(7), conflicts);
655        assertPartialConflict(schedules.get(8), conflicts);
656        assertNotInList(schedules.get(9), conflicts);
657        assertPartialConflict(schedules.get(10), conflicts);
658    }
659
660    private void assertNotInList(ScheduledRecording schedule, List<ConflictInfo> conflicts) {
661        for (ConflictInfo conflictInfo : conflicts) {
662            if (conflictInfo.schedule.equals(schedule)) {
663                fail(schedule + " conflicts with others.");
664            }
665        }
666    }
667
668    private void assertPartialConflict(ScheduledRecording schedule, List<ConflictInfo> conflicts) {
669        for (ConflictInfo conflictInfo : conflicts) {
670            if (conflictInfo.schedule.equals(schedule)) {
671                if (conflictInfo.partialConflict) {
672                    return;
673                } else {
674                    fail(schedule + " fully conflicts with others.");
675                }
676            }
677        }
678        fail(schedule + " doesn't conflict");
679    }
680
681    private void assertFullConflict(ScheduledRecording schedule, List<ConflictInfo> conflicts) {
682        for (ConflictInfo conflictInfo : conflicts) {
683            if (conflictInfo.schedule.equals(schedule)) {
684                if (!conflictInfo.partialConflict) {
685                    return;
686                } else {
687                    fail(schedule + " partially conflicts with others.");
688                }
689            }
690        }
691        fail(schedule + " doesn't conflict");
692    }
693}