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}