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 
17 package com.android.tv.dvr;
18 
19 import static com.google.common.truth.Truth.assertThat;
20 
21 import static org.junit.Assert.fail;
22 
23 import android.os.Build;
24 import android.util.Range;
25 
26 import com.android.tv.dvr.DvrScheduleManager.ConflictInfo;
27 import com.android.tv.dvr.data.ScheduledRecording;
28 import com.android.tv.testing.TestSingletonApp;
29 import com.android.tv.testing.dvr.RecordingTestUtils;
30 
31 import org.junit.Test;
32 import org.junit.runner.RunWith;
33 import org.robolectric.RobolectricTestRunner;
34 import org.robolectric.annotation.Config;
35 
36 import java.util.ArrayList;
37 import java.util.Arrays;
38 import java.util.Collections;
39 import java.util.List;
40 
41 /** Tests for {@link DvrScheduleManager} */
42 @RunWith(RobolectricTestRunner.class)
43 @Config(sdk = Build.VERSION_CODES.N, application = TestSingletonApp.class)
44 public class DvrScheduleManagerTest {
45     private static final String INPUT_ID = "input_id";
46 
47     @Test
testGetConflictingSchedules_emptySchedule()48     public void testGetConflictingSchedules_emptySchedule() {
49         List<ScheduledRecording> schedules = new ArrayList<>();
50         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1)).isEmpty();
51     }
52 
53     @Test
testGetConflictingSchedules_noConflict()54     public void testGetConflictingSchedules_noConflict() {
55         long priority = 0;
56         long channelId = 0;
57         List<ScheduledRecording> schedules = new ArrayList<>();
58 
59         schedules.add(
60                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
61                         ++channelId, ++priority, 0L, 200L));
62         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1)).isEmpty();
63 
64         schedules.add(
65                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
66                         ++channelId, ++priority, 0L, 100L));
67         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2)).isEmpty();
68 
69         schedules.add(
70                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
71                         ++channelId, ++priority, 100L, 200L));
72         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2)).isEmpty();
73 
74         schedules.add(
75                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
76                         ++channelId, ++priority, 0L, 100L));
77         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3)).isEmpty();
78 
79         schedules.add(
80                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
81                         ++channelId, ++priority, 100L, 200L));
82         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3)).isEmpty();
83     }
84 
85     @Test
testGetConflictingSchedules_noTuner()86     public void testGetConflictingSchedules_noTuner() {
87         long priority = 0;
88         long channelId = 0;
89         List<ScheduledRecording> schedules = new ArrayList<>();
90         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 0)).isEmpty();
91 
92         schedules.add(
93                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
94                         ++channelId, ++priority, 0L, 200L));
95         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 0)).isEqualTo(schedules);
96         schedules.add(
97                 0,
98                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
99                         ++channelId, ++priority, 0L, 100L));
100         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 0)).isEqualTo(schedules);
101     }
102 
103     @Test
testGetConflictingSchedules_conflict()104     public void testGetConflictingSchedules_conflict() {
105         long priority = 0;
106         long channelId = 0;
107         List<ScheduledRecording> schedules = new ArrayList<>();
108 
109         ScheduledRecording r1 =
110                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
111                         ++channelId, ++priority, 0L, 200L);
112         schedules.add(r1);
113         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1)).isEmpty();
114 
115         ScheduledRecording r2 =
116                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
117                         ++channelId, ++priority, 0L, 100L);
118         schedules.add(r2);
119         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
120                 .containsExactly(r1)
121                 .inOrder();
122         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2)).isEmpty();
123 
124         ScheduledRecording r3 =
125                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
126                         ++channelId, ++priority, 100L, 200L);
127         schedules.add(r3);
128         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
129                 .containsExactly(r1)
130                 .inOrder();
131         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2)).isEmpty();
132 
133         ScheduledRecording r4 =
134                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
135                         ++channelId, ++priority, 0L, 100L);
136         schedules.add(r4);
137         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
138                 .containsExactly(r2, r1)
139                 .inOrder();
140         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2))
141                 .containsExactly(r1)
142                 .inOrder();
143         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3)).isEmpty();
144 
145         ScheduledRecording r5 =
146                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
147                         ++channelId, ++priority, 100L, 200L);
148         schedules.add(r5);
149         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
150                 .containsExactly(r3, r2, r1)
151                 .inOrder();
152         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2))
153                 .containsExactly(r1)
154                 .inOrder();
155         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3)).isEmpty();
156 
157         ScheduledRecording r6 =
158                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
159                         ++channelId, ++priority, 10L, 90L);
160         schedules.add(r6);
161         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
162                 .containsExactly(r4, r3, r2, r1)
163                 .inOrder();
164         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2))
165                 .containsExactly(r2, r1)
166                 .inOrder();
167         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3))
168                 .containsExactly(r1)
169                 .inOrder();
170         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 4)).isEmpty();
171 
172         ScheduledRecording r7 =
173                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
174                         ++channelId, ++priority, 110L, 190L);
175         schedules.add(r7);
176         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
177                 .containsExactly(r5, r4, r3, r2, r1)
178                 .inOrder();
179         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2))
180                 .containsExactly(r3, r2, r1)
181                 .inOrder();
182         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3))
183                 .containsExactly(r1)
184                 .inOrder();
185         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 4)).isEmpty();
186 
187         ScheduledRecording r8 =
188                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
189                         ++channelId, ++priority, 50L, 150L);
190         schedules.add(r8);
191         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
192                 .containsExactly(r7, r6, r5, r4, r3, r2, r1)
193                 .inOrder();
194         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2))
195                 .containsExactly(r5, r4, r3, r2, r1)
196                 .inOrder();
197         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3))
198                 .containsExactly(r3, r2, r1)
199                 .inOrder();
200         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 4))
201                 .containsExactly(r1)
202                 .inOrder();
203         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 5)).isEmpty();
204     }
205 
206     @Test
testGetConflictingSchedules_conflict2()207     public void testGetConflictingSchedules_conflict2() {
208         // The case when there is a long schedule.
209         long priority = 0;
210         long channelId = 0;
211         List<ScheduledRecording> schedules = new ArrayList<>();
212 
213         ScheduledRecording r1 =
214                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
215                         ++channelId, ++priority, 0L, 1000L);
216         schedules.add(r1);
217         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1)).isEmpty();
218 
219         ScheduledRecording r2 =
220                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
221                         ++channelId, ++priority, 0L, 100L);
222         schedules.add(r2);
223         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
224                 .containsExactly(r1)
225                 .inOrder();
226         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2)).isEmpty();
227 
228         ScheduledRecording r3 =
229                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
230                         ++channelId, ++priority, 100L, 200L);
231         schedules.add(r3);
232         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
233                 .containsExactly(r1)
234                 .inOrder();
235         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2)).isEmpty();
236     }
237 
238     @Test
testGetConflictingSchedules_reverseOrder()239     public void testGetConflictingSchedules_reverseOrder() {
240         long priority = 0;
241         long channelId = 0;
242         List<ScheduledRecording> schedules = new ArrayList<>();
243 
244         ScheduledRecording r1 =
245                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
246                         ++channelId, ++priority, 0L, 200L);
247         schedules.add(0, r1);
248         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1)).isEmpty();
249 
250         ScheduledRecording r2 =
251                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
252                         ++channelId, ++priority, 0L, 100L);
253         schedules.add(0, r2);
254         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
255                 .containsExactly(r1)
256                 .inOrder();
257         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2)).isEmpty();
258 
259         ScheduledRecording r3 =
260                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
261                         ++channelId, ++priority, 100L, 200L);
262         schedules.add(0, r3);
263         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
264                 .containsExactly(r1)
265                 .inOrder();
266         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2)).isEmpty();
267 
268         ScheduledRecording r4 =
269                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
270                         ++channelId, ++priority, 0L, 100L);
271         schedules.add(0, r4);
272         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
273                 .containsExactly(r2, r1)
274                 .inOrder();
275         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2))
276                 .containsExactly(r1)
277                 .inOrder();
278         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3)).isEmpty();
279 
280         ScheduledRecording r5 =
281                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
282                         ++channelId, ++priority, 100L, 200L);
283         schedules.add(0, r5);
284         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
285                 .containsExactly(r3, r2, r1)
286                 .inOrder();
287         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2))
288                 .containsExactly(r1)
289                 .inOrder();
290         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3)).isEmpty();
291 
292         ScheduledRecording r6 =
293                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
294                         ++channelId, ++priority, 10L, 90L);
295         schedules.add(0, r6);
296         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
297                 .containsExactly(r4, r3, r2, r1)
298                 .inOrder();
299         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2))
300                 .containsExactly(r2, r1)
301                 .inOrder();
302         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3))
303                 .containsExactly(r1)
304                 .inOrder();
305         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 4)).isEmpty();
306 
307         ScheduledRecording r7 =
308                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
309                         ++channelId, ++priority, 110L, 190L);
310         schedules.add(0, r7);
311         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
312                 .containsExactly(r5, r4, r3, r2, r1)
313                 .inOrder();
314         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2))
315                 .containsExactly(r3, r2, r1)
316                 .inOrder();
317         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3))
318                 .containsExactly(r1)
319                 .inOrder();
320         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 4)).isEmpty();
321 
322         ScheduledRecording r8 =
323                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
324                         ++channelId, ++priority, 50L, 150L);
325         schedules.add(0, r8);
326         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
327                 .containsExactly(r7, r6, r5, r4, r3, r2, r1)
328                 .inOrder();
329         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 2))
330                 .containsExactly(r5, r4, r3, r2, r1)
331                 .inOrder();
332         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3))
333                 .containsExactly(r3, r2, r1)
334                 .inOrder();
335         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 4))
336                 .containsExactly(r1)
337                 .inOrder();
338         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 5)).isEmpty();
339     }
340 
341     @Test
testGetConflictingSchedules_period1()342     public void testGetConflictingSchedules_period1() {
343         long priority = 0;
344         long channelId = 0;
345         List<ScheduledRecording> schedules = new ArrayList<>();
346 
347         ScheduledRecording r1 =
348                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
349                         ++channelId, ++priority, 0L, 200L);
350         schedules.add(r1);
351         ScheduledRecording r2 =
352                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
353                         ++channelId, ++priority, 0L, 100L);
354         schedules.add(r2);
355         assertThat(
356                         DvrScheduleManager.getConflictingSchedules(
357                                 schedules, 1, Collections.singletonList(new Range<>(10L, 20L))))
358                 .containsExactly(r1)
359                 .inOrder();
360         assertThat(
361                         DvrScheduleManager.getConflictingSchedules(
362                                 schedules, 1, Collections.singletonList(new Range<>(110L, 120L))))
363                 .containsExactly(r1)
364                 .inOrder();
365     }
366 
367     @Test
testGetConflictingSchedules_period2()368     public void testGetConflictingSchedules_period2() {
369         long priority = 0;
370         long channelId = 0;
371         List<ScheduledRecording> schedules = new ArrayList<>();
372 
373         ScheduledRecording r1 =
374                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
375                         ++channelId, ++priority, 0L, 200L);
376         schedules.add(r1);
377         ScheduledRecording r2 =
378                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
379                         ++channelId, ++priority, 100L, 200L);
380         schedules.add(r2);
381         assertThat(
382                         DvrScheduleManager.getConflictingSchedules(
383                                 schedules, 1, Collections.singletonList(new Range<>(10L, 20L))))
384                 .containsExactly(r1)
385                 .inOrder();
386         assertThat(
387                         DvrScheduleManager.getConflictingSchedules(
388                                 schedules, 1, Collections.singletonList(new Range<>(110L, 120L))))
389                 .containsExactly(r1)
390                 .inOrder();
391     }
392 
393     @Test
testGetConflictingSchedules_period3()394     public void testGetConflictingSchedules_period3() {
395         long priority = 0;
396         long channelId = 0;
397         List<ScheduledRecording> schedules = new ArrayList<>();
398 
399         ScheduledRecording r1 =
400                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
401                         ++channelId, ++priority, 0L, 100L);
402         schedules.add(r1);
403         ScheduledRecording r2 =
404                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
405                         ++channelId, ++priority, 100L, 200L);
406         schedules.add(r2);
407         ScheduledRecording r3 =
408                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
409                         ++channelId, ++priority, 0L, 100L);
410         schedules.add(r3);
411         ScheduledRecording r4 =
412                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
413                         ++channelId, ++priority, 100L, 200L);
414         schedules.add(r4);
415         assertThat(
416                         DvrScheduleManager.getConflictingSchedules(
417                                 schedules, 1, Collections.singletonList(new Range<>(10L, 20L))))
418                 .containsExactly(r1)
419                 .inOrder();
420         assertThat(
421                         DvrScheduleManager.getConflictingSchedules(
422                                 schedules, 1, Collections.singletonList(new Range<>(110L, 120L))))
423                 .containsExactly(r2)
424                 .inOrder();
425         assertThat(
426                         DvrScheduleManager.getConflictingSchedules(
427                                 schedules, 1, Collections.singletonList(new Range<>(50L, 150L))))
428                 .containsExactly(r2, r1)
429                 .inOrder();
430         List<Range<Long>> ranges = new ArrayList<>();
431         ranges.add(new Range<>(10L, 20L));
432         ranges.add(new Range<>(110L, 120L));
433         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1, ranges))
434                 .containsExactly(r2, r1)
435                 .inOrder();
436     }
437 
438     @Test
testGetConflictingSchedules_addSchedules1()439     public void testGetConflictingSchedules_addSchedules1() {
440         long priority = 0;
441         long channelId = 0;
442         List<ScheduledRecording> schedules = new ArrayList<>();
443 
444         ScheduledRecording r1 =
445                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
446                         ++channelId, ++priority, 0L, 200L);
447         schedules.add(r1);
448         ScheduledRecording r2 =
449                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
450                         ++channelId, ++priority, 0L, 100L);
451         schedules.add(r2);
452         assertThat(
453                         DvrScheduleManager.getConflictingSchedules(
454                                 Collections.singletonList(
455                                         ScheduledRecording.builder(INPUT_ID, ++channelId, 10L, 20L)
456                                                 .setPriority(++priority)
457                                                 .build()),
458                                 schedules,
459                                 1))
460                 .containsExactly(r2, r1)
461                 .inOrder();
462         assertThat(
463                         DvrScheduleManager.getConflictingSchedules(
464                                 Collections.singletonList(
465                                         ScheduledRecording.builder(
466                                                         INPUT_ID, ++channelId, 110L, 120L)
467                                                 .setPriority(++priority)
468                                                 .build()),
469                                 schedules,
470                                 1))
471                 .containsExactly(r1)
472                 .inOrder();
473     }
474 
475     @Test
testGetConflictingSchedules_addSchedules2()476     public void testGetConflictingSchedules_addSchedules2() {
477         long priority = 0;
478         long channelId = 0;
479         List<ScheduledRecording> schedules = new ArrayList<>();
480 
481         ScheduledRecording r1 =
482                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
483                         ++channelId, ++priority, 0L, 200L);
484         schedules.add(r1);
485         ScheduledRecording r2 =
486                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
487                         ++channelId, ++priority, 100L, 200L);
488         schedules.add(r2);
489         assertThat(
490                         DvrScheduleManager.getConflictingSchedules(
491                                 Collections.singletonList(
492                                         ScheduledRecording.builder(INPUT_ID, ++channelId, 10L, 20L)
493                                                 .setPriority(++priority)
494                                                 .build()),
495                                 schedules,
496                                 1))
497                 .containsExactly(r1)
498                 .inOrder();
499         assertThat(
500                         DvrScheduleManager.getConflictingSchedules(
501                                 Collections.singletonList(
502                                         ScheduledRecording.builder(
503                                                         INPUT_ID, ++channelId, 110L, 120L)
504                                                 .setPriority(++priority)
505                                                 .build()),
506                                 schedules,
507                                 1))
508                 .containsExactly(r2, r1)
509                 .inOrder();
510     }
511 
512     @Test
testGetConflictingSchedules_addLowestPriority()513     public void testGetConflictingSchedules_addLowestPriority() {
514         long priority = 0;
515         long channelId = 0;
516         List<ScheduledRecording> schedules = new ArrayList<>();
517 
518         ScheduledRecording r1 =
519                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
520                         ++channelId, ++priority, 0L, 400L);
521         schedules.add(r1);
522         ScheduledRecording r2 =
523                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
524                         ++channelId, ++priority, 100L, 200L);
525         schedules.add(r2);
526         // Returning r1 even though r1 has the higher priority than the new one. That's because r1
527         // starts at 0 and stops at 100, and the new one will be recorded successfully.
528         assertThat(
529                         DvrScheduleManager.getConflictingSchedules(
530                                 Collections.singletonList(
531                                         ScheduledRecording.builder(
532                                                         INPUT_ID, ++channelId, 200L, 300L)
533                                                 .setPriority(0)
534                                                 .build()),
535                                 schedules,
536                                 1))
537                 .containsExactly(r1)
538                 .inOrder();
539     }
540 
541     @Test
testGetConflictingSchedules_sameChannel()542     public void testGetConflictingSchedules_sameChannel() {
543         long priority = 0;
544         long channelId = 1;
545         List<ScheduledRecording> schedules = new ArrayList<>();
546         schedules.add(
547                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
548                         channelId, ++priority, 0L, 200L));
549         schedules.add(
550                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
551                         channelId, ++priority, 0L, 200L));
552         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 3)).isEmpty();
553     }
554 
555     @Test
testGetConflictingSchedule_startEarlyAndFail()556     public void testGetConflictingSchedule_startEarlyAndFail() {
557         long priority = 0;
558         long channelId = 0;
559         List<ScheduledRecording> schedules = new ArrayList<>();
560         ScheduledRecording r1 =
561                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
562                         ++channelId, ++priority, 200L, 300L);
563         schedules.add(r1);
564         ScheduledRecording r2 =
565                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
566                         ++channelId, ++priority, 0L, 400L);
567         schedules.add(r2);
568         ScheduledRecording r3 =
569                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
570                         ++channelId, ++priority, 100L, 200L);
571         schedules.add(r3);
572         // r2 starts recording and fails when r3 starts. r1 is recorded successfully.
573         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
574                 .containsExactly(r2)
575                 .inOrder();
576     }
577 
578     @Test
testGetConflictingSchedule_startLate()579     public void testGetConflictingSchedule_startLate() {
580         long priority = 0;
581         long channelId = 0;
582         List<ScheduledRecording> schedules = new ArrayList<>();
583         ScheduledRecording r1 =
584                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
585                         ++channelId, ++priority, 200L, 400L);
586         schedules.add(r1);
587         ScheduledRecording r2 =
588                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
589                         ++channelId, ++priority, 100L, 300L);
590         schedules.add(r2);
591         ScheduledRecording r3 =
592                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
593                         ++channelId, ++priority, 0L, 200L);
594         schedules.add(r3);
595         // r2 and r1 are clipped.
596         assertThat(DvrScheduleManager.getConflictingSchedules(schedules, 1))
597                 .containsExactly(r2, r1)
598                 .inOrder();
599     }
600 
601     @Test
testGetConflictingSchedulesForTune_canTune()602     public void testGetConflictingSchedulesForTune_canTune() {
603         // Can tune to the recorded channel if tuner count is 1.
604         long priority = 0;
605         long channelId = 1;
606         List<ScheduledRecording> schedules = new ArrayList<>();
607         schedules.add(
608                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
609                         channelId, ++priority, 0L, 200L));
610         assertThat(
611                         DvrScheduleManager.getConflictingSchedulesForTune(
612                                 INPUT_ID, channelId, 0L, priority + 1, schedules, 1))
613                 .isEmpty();
614     }
615 
616     @Test
testGetConflictingSchedulesForTune_cannotTune()617     public void testGetConflictingSchedulesForTune_cannotTune() {
618         // Can't tune to a channel if other channel is recording and tuner count is 1.
619         long priority = 0;
620         long channelId = 1;
621         List<ScheduledRecording> schedules = new ArrayList<>();
622         schedules.add(
623                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
624                         channelId, ++priority, 0L, 200L));
625         assertThat(
626                         DvrScheduleManager.getConflictingSchedulesForTune(
627                                 INPUT_ID, channelId + 1, 0L, priority + 1, schedules, 1))
628                 .containsExactly(schedules.get(0))
629                 .inOrder();
630     }
631 
632     @Test
testGetConflictingSchedulesForWatching_otherChannels()633     public void testGetConflictingSchedulesForWatching_otherChannels() {
634         // The other channels are to be recorded.
635         long priority = 0;
636         long channelToWatch = 1;
637         long channelId = 1;
638         List<ScheduledRecording> schedules = new ArrayList<>();
639         ScheduledRecording r1 =
640                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
641                         ++channelId, ++priority, 0L, 200L);
642         schedules.add(r1);
643         ScheduledRecording r2 =
644                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
645                         ++channelId, ++priority, 0L, 200L);
646         schedules.add(r2);
647         assertThat(
648                         DvrScheduleManager.getConflictingSchedulesForWatching(
649                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 3))
650                 .isEmpty();
651         assertThat(
652                         DvrScheduleManager.getConflictingSchedulesForWatching(
653                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2))
654                 .containsExactly(r1)
655                 .inOrder();
656     }
657 
658     @Test
testGetConflictingSchedulesForWatching_sameChannel1()659     public void testGetConflictingSchedulesForWatching_sameChannel1() {
660         long priority = 0;
661         long channelToWatch = 1;
662         long channelId = 1;
663         List<ScheduledRecording> schedules = new ArrayList<>();
664         ScheduledRecording r1 =
665                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
666                         channelToWatch, ++priority, 0L, 200L);
667         schedules.add(r1);
668         ScheduledRecording r2 =
669                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
670                         ++channelId, ++priority, 0L, 200L);
671         schedules.add(r2);
672         assertThat(
673                         DvrScheduleManager.getConflictingSchedulesForWatching(
674                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2))
675                 .isEmpty();
676         assertThat(
677                         DvrScheduleManager.getConflictingSchedulesForWatching(
678                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1))
679                 .containsExactly(r2)
680                 .inOrder();
681     }
682 
683     @Test
testGetConflictingSchedulesForWatching_sameChannel2()684     public void testGetConflictingSchedulesForWatching_sameChannel2() {
685         long priority = 0;
686         long channelToWatch = 1;
687         long channelId = 1;
688         List<ScheduledRecording> schedules = new ArrayList<>();
689         ScheduledRecording r1 =
690                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
691                         ++channelId, ++priority, 0L, 200L);
692         schedules.add(r1);
693         ScheduledRecording r2 =
694                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
695                         channelToWatch, ++priority, 0L, 200L);
696         schedules.add(r2);
697         assertThat(
698                         DvrScheduleManager.getConflictingSchedulesForWatching(
699                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2))
700                 .isEmpty();
701         assertThat(
702                         DvrScheduleManager.getConflictingSchedulesForWatching(
703                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1))
704                 .containsExactly(r1)
705                 .inOrder();
706     }
707 
708     @Test
testGetConflictingSchedulesForWatching_sameChannelConflict1()709     public void testGetConflictingSchedulesForWatching_sameChannelConflict1() {
710         long priority = 0;
711         long channelToWatch = 1;
712         long channelId = 1;
713         List<ScheduledRecording> schedules = new ArrayList<>();
714         ScheduledRecording r1 =
715                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
716                         ++channelId, ++priority, 0L, 200L);
717         schedules.add(r1);
718         ScheduledRecording r2 =
719                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
720                         channelToWatch, ++priority, 0L, 200L);
721         schedules.add(r2);
722         ScheduledRecording r3 =
723                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
724                         channelToWatch, ++priority, 0L, 200L);
725         schedules.add(r3);
726         assertThat(
727                         DvrScheduleManager.getConflictingSchedulesForWatching(
728                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 3))
729                 .containsExactly(r2)
730                 .inOrder();
731         assertThat(
732                         DvrScheduleManager.getConflictingSchedulesForWatching(
733                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2))
734                 .containsExactly(r2)
735                 .inOrder();
736         assertThat(
737                         DvrScheduleManager.getConflictingSchedulesForWatching(
738                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1))
739                 .containsExactly(r2, r1)
740                 .inOrder();
741     }
742 
743     @Test
testGetConflictingSchedulesForWatching_sameChannelConflict2()744     public void testGetConflictingSchedulesForWatching_sameChannelConflict2() {
745         long priority = 0;
746         long channelToWatch = 1;
747         long channelId = 1;
748         List<ScheduledRecording> schedules = new ArrayList<>();
749         ScheduledRecording r1 =
750                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
751                         channelToWatch, ++priority, 0L, 200L);
752         schedules.add(r1);
753         ScheduledRecording r2 =
754                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
755                         channelToWatch, ++priority, 0L, 200L);
756         schedules.add(r2);
757         ScheduledRecording r3 =
758                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
759                         ++channelId, ++priority, 0L, 200L);
760         schedules.add(r3);
761         assertThat(
762                         DvrScheduleManager.getConflictingSchedulesForWatching(
763                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 3))
764                 .containsExactly(r1)
765                 .inOrder();
766         assertThat(
767                         DvrScheduleManager.getConflictingSchedulesForWatching(
768                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2))
769                 .containsExactly(r1)
770                 .inOrder();
771         assertThat(
772                         DvrScheduleManager.getConflictingSchedulesForWatching(
773                                 INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1))
774                 .containsExactly(r3, r1)
775                 .inOrder();
776     }
777 
778     @Test
testPartiallyConflictingSchedules()779     public void testPartiallyConflictingSchedules() {
780         long priority = 100;
781         long channelId = 0;
782         List<ScheduledRecording> schedules =
783                 new ArrayList<>(
784                         Arrays.asList(
785                                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
786                                         ++channelId, --priority, 0L, 400L),
787                                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
788                                         ++channelId, --priority, 0L, 200L),
789                                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
790                                         ++channelId, --priority, 200L, 500L),
791                                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
792                                         ++channelId, --priority, 400L, 600L),
793                                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
794                                         ++channelId, --priority, 700L, 800L),
795                                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
796                                         ++channelId, --priority, 600L, 900L),
797                                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
798                                         ++channelId, --priority, 800L, 900L),
799                                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
800                                         ++channelId, --priority, 800L, 900L),
801                                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
802                                         ++channelId, --priority, 750L, 850L),
803                                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
804                                         ++channelId, --priority, 300L, 450L),
805                                 RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(
806                                         ++channelId, --priority, 50L, 900L)));
807         List<ConflictInfo> conflicts = DvrScheduleManager.getConflictingSchedulesInfo(schedules, 1);
808 
809         assertNotInList(schedules.get(0), conflicts);
810         assertFullConflict(schedules.get(1), conflicts);
811         assertPartialConflict(schedules.get(2), conflicts);
812         assertPartialConflict(schedules.get(3), conflicts);
813         assertNotInList(schedules.get(4), conflicts);
814         assertPartialConflict(schedules.get(5), conflicts);
815         assertNotInList(schedules.get(6), conflicts);
816         assertFullConflict(schedules.get(7), conflicts);
817         assertFullConflict(schedules.get(8), conflicts);
818         assertFullConflict(schedules.get(9), conflicts);
819         assertFullConflict(schedules.get(10), conflicts);
820 
821         conflicts = DvrScheduleManager.getConflictingSchedulesInfo(schedules, 2);
822 
823         assertNotInList(schedules.get(0), conflicts);
824         assertNotInList(schedules.get(1), conflicts);
825         assertNotInList(schedules.get(2), conflicts);
826         assertNotInList(schedules.get(3), conflicts);
827         assertNotInList(schedules.get(4), conflicts);
828         assertNotInList(schedules.get(5), conflicts);
829         assertNotInList(schedules.get(6), conflicts);
830         assertFullConflict(schedules.get(7), conflicts);
831         assertFullConflict(schedules.get(8), conflicts);
832         assertFullConflict(schedules.get(9), conflicts);
833         assertPartialConflict(schedules.get(10), conflicts);
834 
835         conflicts = DvrScheduleManager.getConflictingSchedulesInfo(schedules, 3);
836 
837         assertNotInList(schedules.get(0), conflicts);
838         assertNotInList(schedules.get(1), conflicts);
839         assertNotInList(schedules.get(2), conflicts);
840         assertNotInList(schedules.get(3), conflicts);
841         assertNotInList(schedules.get(4), conflicts);
842         assertNotInList(schedules.get(5), conflicts);
843         assertNotInList(schedules.get(6), conflicts);
844         assertNotInList(schedules.get(7), conflicts);
845         assertPartialConflict(schedules.get(8), conflicts);
846         assertNotInList(schedules.get(9), conflicts);
847         assertPartialConflict(schedules.get(10), conflicts);
848     }
849 
assertNotInList(ScheduledRecording schedule, List<ConflictInfo> conflicts)850     private void assertNotInList(ScheduledRecording schedule, List<ConflictInfo> conflicts) {
851         for (ConflictInfo conflictInfo : conflicts) {
852             if (conflictInfo.schedule.equals(schedule)) {
853                 fail(schedule + " conflicts with others.");
854             }
855         }
856     }
857 
assertPartialConflict(ScheduledRecording schedule, List<ConflictInfo> conflicts)858     private void assertPartialConflict(ScheduledRecording schedule, List<ConflictInfo> conflicts) {
859         for (ConflictInfo conflictInfo : conflicts) {
860             if (conflictInfo.schedule.equals(schedule)) {
861                 if (conflictInfo.partialConflict) {
862                     return;
863                 } else {
864                     fail(schedule + " fully conflicts with others.");
865                 }
866             }
867         }
868         fail(schedule + " doesn't conflict");
869     }
870 
assertFullConflict(ScheduledRecording schedule, List<ConflictInfo> conflicts)871     private void assertFullConflict(ScheduledRecording schedule, List<ConflictInfo> conflicts) {
872         for (ConflictInfo conflictInfo : conflicts) {
873             if (conflictInfo.schedule.equals(schedule)) {
874                 if (!conflictInfo.partialConflict) {
875                     return;
876                 } else {
877                     fail(schedule + " partially conflicts with others.");
878                 }
879             }
880         }
881         fail(schedule + " doesn't conflict");
882     }
883 }
884