@Test public void encryptionKey_keyStorage() throws Exception { // Generates a key and uses it in a RealmConfiguration. byte[] oldKey = TestHelper.getRandomKey(12345); byte[] key = oldKey; RealmConfiguration config = new RealmConfiguration.Builder(context) .directory(configFactory.getRoot()) .encryptionKey(key) .build(); // Generates a different key and assigns it to the same variable. byte[] newKey = TestHelper.getRandomKey(67890); MoreAsserts.assertNotEqual(key, newKey); key = newKey; MoreAsserts.assertEquals(key, newKey); // Ensures that the stored key did not change. MoreAsserts.assertEquals(oldKey, config.getEncryptionKey()); }
public void assertEquals(FakeTrackOutput expected) { Assert.assertEquals(expected.format, format); Assert.assertEquals(expected.sampleTimesUs.size(), sampleTimesUs.size()); MoreAsserts.assertEquals(expected.sampleData, sampleData); for (int i = 0; i < sampleTimesUs.size(); i++) { Assert.assertEquals(expected.sampleTimesUs.get(i), sampleTimesUs.get(i)); Assert.assertEquals(expected.sampleFlags.get(i), sampleFlags.get(i)); Assert.assertEquals(expected.sampleStartOffsets.get(i), sampleStartOffsets.get(i)); Assert.assertEquals(expected.sampleEndOffsets.get(i), sampleEndOffsets.get(i)); if (expected.sampleEncryptionKeys.get(i) == null) { Assert.assertNull(sampleEncryptionKeys.get(i)); } else { MoreAsserts.assertEquals(expected.sampleEncryptionKeys.get(i), sampleEncryptionKeys.get(i)); } } }
/** Tests that the translator service can translate computer braille. */ public void testTranslateComputerBraille() throws Exception { ITranslatorService service = getServiceInterface(); assertTrue("expected braille table check to succeed", service.checkTable(TEST_BRAILLE_TABLE_ID)); TranslationResult result = service.translate("Hello!", TEST_BRAILLE_TABLE_ID, -1); MoreAsserts.assertEquals( new byte[] { 0x53, 0x11, 0x07, 0x07, 0x15, 0x2e }, result.getCells()); MoreAsserts.assertEquals(new int[] { 0, 1, 2, 3, 4, 5 }, result.getTextToBraillePositions()); MoreAsserts.assertEquals(new int[] { 0, 1, 2, 3, 4, 5 }, result.getBrailleToTextPositions()); assertEquals(-1, result.getCursorPosition()); }
public void testGetConflictingSchedules_noConflict() { long priority = 0; long channelId = 0; List<ScheduledRecording> schedules = new ArrayList<>(); schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId, ++priority, 0L, 200L)); MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 1)); schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId, ++priority, 0L, 100L)); MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2)); schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId, ++priority, 100L, 200L)); MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2)); schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId, ++priority, 0L, 100L)); MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 3)); schedules.add(RecordingTestUtils.createTestRecordingWithPriorityAndPeriod(++channelId, ++priority, 100L, 200L)); MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 3)); }
public void testGetConflictingSchedules_conflict2() { // The case when there is a long schedule. long priority = 0; long channelId = 0; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 1000L); schedules.add(r1); MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 1)); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 100L); schedules.add(r2); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1), r1); MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2)); ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 100L, 200L); schedules.add(r3); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1), r1); MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedules(schedules, 2)); }
public void testGetConflictingSchedules_period1() { long priority = 0; long channelId = 0; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 200L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 100L); schedules.add(r2); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1, Collections.singletonList(new Range<>(10L, 20L))), r1); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1, Collections.singletonList(new Range<>(110L, 120L))), r1); }
public void testGetConflictingSchedules_period2() { long priority = 0; long channelId = 0; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 200L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 100L, 200L); schedules.add(r2); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1, Collections.singletonList(new Range<>(10L, 20L))), r1); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1, Collections.singletonList(new Range<>(110L, 120L))), r1); }
public void testGetConflictingSchedules_addSchedules1() { long priority = 0; long channelId = 0; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 200L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 100L); schedules.add(r2); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules( Collections.singletonList( ScheduledRecording.builder(INPUT_ID, ++channelId, 10L, 20L) .setPriority(++priority).build()), schedules, 1), r2, r1); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules( Collections.singletonList( ScheduledRecording.builder(INPUT_ID, ++channelId, 110L, 120L) .setPriority(++priority).build()), schedules, 1), r1); }
public void testGetConflictingSchedules_addSchedules2() { long priority = 0; long channelId = 0; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 200L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 100L, 200L); schedules.add(r2); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules( Collections.singletonList( ScheduledRecording.builder(INPUT_ID, ++channelId, 10L, 20L) .setPriority(++priority).build()), schedules, 1), r1); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules( Collections.singletonList( ScheduledRecording.builder(INPUT_ID, ++channelId, 110L, 120L) .setPriority(++priority).build()), schedules, 1), r2, r1); }
public void testGetConflictingSchedules_addLowestPriority() { long priority = 0; long channelId = 0; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 400L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 100L, 200L); schedules.add(r2); // Returning r1 even though r1 has the higher priority than the new one. That's because r1 // starts at 0 and stops at 100, and the new one will be recorded successfully. MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules( Collections.singletonList( ScheduledRecording.builder(INPUT_ID, ++channelId, 200L, 300L) .setPriority(0).build()), schedules, 1), r1); }
public void testGetConflictingSchedule_startEarlyAndFail() { long priority = 0; long channelId = 0; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 200L, 300L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 400L); schedules.add(r2); ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 100L, 200L); schedules.add(r3); // r2 starts recording and fails when r3 starts. r1 is recorded successfully. MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1), r2); }
public void testGetConflictingSchedule_startLate() { long priority = 0; long channelId = 0; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 200L, 400L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 100L, 300L); schedules.add(r2); ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 200L); schedules.add(r3); // r2 and r1 are clipped. MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedules(schedules, 1), r2, r1); }
public void testGetConflictingSchedulesForWatching_otherChannels() { // The other channels are to be recorded. long priority = 0; long channelToWatch = 1; long channelId = 1; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 200L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 200L); schedules.add(r2); MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 3)); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2), r1); }
public void testGetConflictingSchedulesForWatching_sameChannel1() { long priority = 0; long channelToWatch = 1; long channelId = 1; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( channelToWatch, ++priority, 0L, 200L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 200L); schedules.add(r2); MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2)); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1), r2); }
public void testGetConflictingSchedulesForWatching_sameChannel2() { long priority = 0; long channelToWatch = 1; long channelId = 1; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 200L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( channelToWatch, ++priority, 0L, 200L); schedules.add(r2); MoreAsserts.assertEmpty(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2)); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1), r1); }
public void testGetConflictingSchedulesForWatching_sameChannelConflict1() { long priority = 0; long channelToWatch = 1; long channelId = 1; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 200L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( channelToWatch, ++priority, 0L, 200L); schedules.add(r2); ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( channelToWatch, ++priority, 0L, 200L); schedules.add(r3); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 3), r2); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2), r2); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1), r2, r1); }
public void testGetConflictingSchedulesForWatching_sameChannelConflict2() { long priority = 0; long channelToWatch = 1; long channelId = 1; List<ScheduledRecording> schedules = new ArrayList<>(); ScheduledRecording r1 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( channelToWatch, ++priority, 0L, 200L); schedules.add(r1); ScheduledRecording r2 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( channelToWatch, ++priority, 0L, 200L); schedules.add(r2); ScheduledRecording r3 = RecordingTestUtils.createTestRecordingWithPriorityAndPeriod( ++channelId, ++priority, 0L, 200L); schedules.add(r3); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 3), r1); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 2), r1); MoreAsserts.assertContentsInOrder(DvrScheduleManager.getConflictingSchedulesForWatching( INPUT_ID, channelToWatch, 0L, ++priority, schedules, 1), r3, r1); }
public void testPickOneProgramPerEpisode_manyPerEpisode() { SeriesRecording seriesRecording = SeriesRecording.buildFrom(mBaseSeriesRecording) .setId(SERIES_RECORDING_ID1).build(); mDataManager.addSeriesRecording(seriesRecording); List<Program> programs = new ArrayList<>(); Program program1 = new Program.Builder(mBaseProgram).setSeasonNumber(SEASON_NUMBER1) .setEpisodeNumber(EPISODE_NUMBER1).setStartTimeUtcMillis(0).build(); programs.add(program1); Program program2 = new Program.Builder(program1).setStartTimeUtcMillis(1).build(); programs.add(program2); Program program3 = new Program.Builder(mBaseProgram).setSeasonNumber(SEASON_NUMBER2) .setEpisodeNumber(EPISODE_NUMBER2).build(); programs.add(program3); Program program4 = new Program.Builder(program1).setStartTimeUtcMillis(1).build(); programs.add(program4); LongSparseArray<List<Program>> result = SeriesRecordingScheduler.pickOneProgramPerEpisode( mDataManager, Collections.singletonList(seriesRecording), programs); MoreAsserts.assertContentsInAnyOrder(result.get(SERIES_RECORDING_ID1), program1, program3); }
public void testRecommendChannels_includeRecommendedOnly_allChannelsHaveScore() { createRecommender(true, START_DATAMANAGER_RUNNABLE_ADD_FOUR_CHANNELS); setChannelScores_scoreIncreasesAsChannelIdIncreases(); // recommendChannels must be sorted by score in decreasing order. // (i.e. sorted by channel ID in decreasing order in this case) MoreAsserts.assertContentsInOrder(mRecommender.recommendChannels(), mChannel_4, mChannel_3, mChannel_2, mChannel_1); assertEquals(0, mRecommender.recommendChannels(-5).size()); assertEquals(0, mRecommender.recommendChannels(0).size()); MoreAsserts.assertContentsInOrder(mRecommender.recommendChannels(3), mChannel_4, mChannel_3, mChannel_2); MoreAsserts.assertContentsInOrder(mRecommender.recommendChannels(4), mChannel_4, mChannel_3, mChannel_2, mChannel_1); MoreAsserts.assertContentsInOrder(mRecommender.recommendChannels(5), mChannel_4, mChannel_3, mChannel_2, mChannel_1); }
public void testRecommendChannels_notIncludeRecommendedOnly_allChannelsHaveScore() { createRecommender(false, START_DATAMANAGER_RUNNABLE_ADD_FOUR_CHANNELS); setChannelScores_scoreIncreasesAsChannelIdIncreases(); // recommendChannels must be sorted by score in decreasing order. // (i.e. sorted by channel ID in decreasing order in this case) MoreAsserts.assertContentsInOrder(mRecommender.recommendChannels(), mChannel_4, mChannel_3, mChannel_2, mChannel_1); assertEquals(0, mRecommender.recommendChannels(-5).size()); assertEquals(0, mRecommender.recommendChannels(0).size()); MoreAsserts.assertContentsInOrder(mRecommender.recommendChannels(3), mChannel_4, mChannel_3, mChannel_2); MoreAsserts.assertContentsInOrder(mRecommender.recommendChannels(4), mChannel_4, mChannel_3, mChannel_2, mChannel_1); MoreAsserts.assertContentsInOrder(mRecommender.recommendChannels(5), mChannel_4, mChannel_3, mChannel_2, mChannel_1); }
public void testRecommendChannels_includeRecommendedOnly_fewChannelsHaveScore() { createRecommender(true, START_DATAMANAGER_RUNNABLE_ADD_FOUR_CHANNELS); mEvaluator.setChannelScore(mChannel_1.getId(), 1.0); mEvaluator.setChannelScore(mChannel_2.getId(), 1.0); // Only two channels are recommended because recommender doesn't recommend other channels. MoreAsserts.assertContentsInAnyOrder(mRecommender.recommendChannels(), mChannel_1, mChannel_2); assertEquals(0, mRecommender.recommendChannels(-5).size()); assertEquals(0, mRecommender.recommendChannels(0).size()); MoreAsserts.assertContentsInAnyOrder(mRecommender.recommendChannels(3), mChannel_1, mChannel_2); MoreAsserts.assertContentsInAnyOrder(mRecommender.recommendChannels(4), mChannel_1, mChannel_2); MoreAsserts.assertContentsInAnyOrder(mRecommender.recommendChannels(5), mChannel_1, mChannel_2); }
public void testRecommendChannels_notIncludeRecommendedOnly_fewChannelsHaveScore() { createRecommender(false, START_DATAMANAGER_RUNNABLE_ADD_FOUR_CHANNELS); mEvaluator.setChannelScore(mChannel_1.getId(), 1.0); mEvaluator.setChannelScore(mChannel_2.getId(), 1.0); assertEquals(4, mRecommender.recommendChannels().size()); MoreAsserts.assertContentsInAnyOrder(mRecommender.recommendChannels().subList(0, 2), mChannel_1, mChannel_2); assertEquals(0, mRecommender.recommendChannels(-5).size()); assertEquals(0, mRecommender.recommendChannels(0).size()); assertEquals(3, mRecommender.recommendChannels(3).size()); MoreAsserts.assertContentsInAnyOrder(mRecommender.recommendChannels(3).subList(0, 2), mChannel_1, mChannel_2); assertEquals(4, mRecommender.recommendChannels(4).size()); MoreAsserts.assertContentsInAnyOrder(mRecommender.recommendChannels(4).subList(0, 2), mChannel_1, mChannel_2); assertEquals(4, mRecommender.recommendChannels(5).size()); MoreAsserts.assertContentsInAnyOrder(mRecommender.recommendChannels(5).subList(0, 2), mChannel_1, mChannel_2); }
public void testGetChannelSortKey_recommendFewChannels() { // Test with recommending 3 channels. createRecommender(true, START_DATAMANAGER_RUNNABLE_ADD_FOUR_CHANNELS); setChannelScores_scoreIncreasesAsChannelIdIncreases(); List<Channel> expectedChannelList = mRecommender.recommendChannels(3); // A channel which is not recommended by the recommender has to get an invalid sort key. assertEquals(Recommender.INVALID_CHANNEL_SORT_KEY, mRecommender.getChannelSortKey(mChannel_1.getId())); List<Channel> channelList = Arrays.asList(mChannel_2, mChannel_3, mChannel_4); Collections.sort(channelList, CHANNEL_SORT_KEY_COMPARATOR); MoreAsserts.assertContentsInOrder(channelList, expectedChannelList.toArray()); assertSortKeyNotInvalid(channelList); }
@Suppress // not supporting localized collators @MediumTest public void testLocaleenUS() throws Exception { insertStrings(); Log.i("LocaleTest", "about to call setLocale en_US"); mDatabase.setLocale(new Locale("en", "US")); String[] results; results = query("SELECT data FROM test ORDER BY data COLLATE LOCALIZED ASC"); // The database code currently uses PRIMARY collation strength, // meaning that all versions of a character compare equal (regardless // of case or accents), leaving the "cote" flavors in database order. MoreAsserts.assertEquals(results, new String[] { STRINGS[4], // "boy" STRINGS[0], // sundry forms of "cote" STRINGS[1], STRINGS[2], STRINGS[3], STRINGS[6], // "COTE" STRINGS[5], // "dog" }); }
private void assertReadData(CacheDataSource cacheDataSource, boolean unknownLength, int position, int length) throws IOException { int actualLength = TEST_DATA.length - position; if (length != C.LENGTH_UNSET) { actualLength = Math.min(actualLength, length); } assertEquals(unknownLength ? length : actualLength, cacheDataSource.open(new DataSpec(Uri.EMPTY, position, length, KEY_1))); byte[] buffer = new byte[100]; int index = 0; while (true) { int read = cacheDataSource.read(buffer, index, buffer.length - index); if (read == C.RESULT_END_OF_INPUT) { break; } index += read; } assertEquals(actualLength, index); MoreAsserts.assertEquals(Arrays.copyOfRange(TEST_DATA, position, position + actualLength), Arrays.copyOf(buffer, index)); cacheDataSource.close(); }
public void testParser() throws Exception { League league = new League.Builder() .league_key("key1") .league_name("name1") .build(); InputStream is = getInstrumentation().getContext().getResources() .openRawResource(R.raw.league_example); // Can't use try-with-resources here; we support pre-API-19 devices. //noinspection TryFinallyCanBeTryWithResources try { InputStreamReader isr = new InputStreamReader(is, "UTF-8"); MoreAsserts.assertEquals(new League[] { league }, LeagueParser.parseXml(isr)); } finally { is.close(); } }
public void testUpdateLeagues_clearAll() { League[] leagues = new League[] { new League.Builder() .account_name(ACCOUNT.name) .league_key("key") .league_name("name") .build(), }; League[] leagues2 = new League[] { new League.Builder() .account_name(ACCOUNT2.name) .league_key("key") .league_name("name") .build(), }; League[] noLeagues = new League[] {}; LeagueTable.updateLeagues(mTestContext, ACCOUNT, leagues); LeagueTable.updateLeagues(mTestContext, ACCOUNT2, leagues2); LeagueTable.updateLeagues(mTestContext, ACCOUNT, noLeagues); MoreAsserts.assertEquals(noLeagues, LeagueTable.getLeagues(mTestContext, ACCOUNT)); MoreAsserts.assertEquals(leagues2, LeagueTable.getLeagues(mTestContext, ACCOUNT2)); }
public void testConstruct_whenDatabaseWithoutProviderColumn() { deleteAccountDb(); SQLiteDatabase database = DependencyInjector.getContext().openOrCreateDatabase( AccountDb.PATH, Context.MODE_PRIVATE, null); database.execSQL("CREATE TABLE " + AccountDb.TABLE_NAME + " (first INTEGER)"); MoreAsserts.assertContentsInAnyOrder( AccountDb.listTableColumnNamesLowerCase(database, AccountDb.TABLE_NAME), "first"); database.close(); database = null; accountDb = DependencyInjector.getAccountDb(); MoreAsserts.assertContentsInAnyOrder( AccountDb.listTableColumnNamesLowerCase(accountDb.mDatabase, AccountDb.TABLE_NAME), "first", AccountDb.PROVIDER_COLUMN); }
@MediumTest public void testGetSpans() { Spannable spannable = newSpannableWithText("abcdef"); Object emptySpan = new Object(); spannable.setSpan(emptySpan, 1, 1, 0); Object unemptySpan = new Object(); spannable.setSpan(unemptySpan, 1, 2, 0); Object[] spans; // Empty spans are included when they merely abut the query region // but other spans are not, unless the query region is empty, in // in which case any abutting spans are returned. spans = spannable.getSpans(0, 1, Object.class); MoreAsserts.assertEquals(new Object[]{emptySpan}, spans); spans = spannable.getSpans(0, 2, Object.class); MoreAsserts.assertEquals(new Object[]{emptySpan, unemptySpan}, spans); spans = spannable.getSpans(1, 2, Object.class); MoreAsserts.assertEquals(new Object[]{emptySpan, unemptySpan}, spans); spans = spannable.getSpans(2, 2, Object.class); MoreAsserts.assertEquals(new Object[]{unemptySpan}, spans); }
/** Asserts that the cache contains the given data for {@code uriString}. */ public static void assertDataCached(Cache cache, Uri uri, byte[] expected) throws IOException { CacheDataSource dataSource = new CacheDataSource(cache, DummyDataSource.INSTANCE, 0); ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); DataSourceInputStream inputStream = new DataSourceInputStream(dataSource, new DataSpec(uri, DataSpec.FLAG_ALLOW_CACHING_UNKNOWN_LENGTH)); try { inputStream.open(); byte[] buffer = new byte[1024]; int bytesRead; while ((bytesRead = inputStream.read(buffer)) != -1) { outputStream.write(buffer, 0, bytesRead); } } catch (IOException e) { // Ignore } finally { inputStream.close(); } MoreAsserts.assertEquals("Cached data doesn't match expected for '" + uri + "',", expected, outputStream.toByteArray()); }
public void assertEquals(FakeTrackOutput expected) { Assert.assertEquals(expected.format, format); Assert.assertEquals(expected.sampleTimesUs.size(), sampleTimesUs.size()); MoreAsserts.assertEquals(expected.sampleData, sampleData); for (int i = 0; i < sampleTimesUs.size(); i++) { Assert.assertEquals(expected.sampleTimesUs.get(i), sampleTimesUs.get(i)); Assert.assertEquals(expected.sampleFlags.get(i), sampleFlags.get(i)); Assert.assertEquals(expected.sampleStartOffsets.get(i), sampleStartOffsets.get(i)); Assert.assertEquals(expected.sampleEndOffsets.get(i), sampleEndOffsets.get(i)); if (expected.cryptoDatas.get(i) == null) { Assert.assertNull(cryptoDatas.get(i)); } else { Assert.assertEquals(expected.cryptoDatas.get(i), cryptoDatas.get(i)); } } }
public void testStoreV1() throws Exception { index.addNew(new CachedContent(2, "KLMNO", 2560)); index.addNew(new CachedContent(5, "ABCDE", 10)); index.store(); byte[] buffer = new byte[testIndexV1File.length]; FileInputStream fos = new FileInputStream(new File(cacheDir, CachedContentIndex.FILE_NAME)); assertEquals(testIndexV1File.length, fos.read(buffer)); assertEquals(-1, fos.read()); fos.close(); // TODO: The order of the CachedContent stored in index file isn't defined so this test may fail // on a different implementation of the underlying set MoreAsserts.assertEquals(testIndexV1File, buffer); }
private static void assertManifestEquals(SsManifest expected, SsManifest actual) { assertEquals(expected.durationUs, actual.durationUs); assertEquals(expected.dvrWindowLengthUs, actual.dvrWindowLengthUs); assertEquals(expected.isLive, actual.isLive); assertEquals(expected.lookAheadCount, actual.lookAheadCount); assertEquals(expected.majorVersion, actual.majorVersion); assertEquals(expected.minorVersion, actual.minorVersion); assertEquals(expected.protectionElement.uuid, actual.protectionElement.uuid); assertEquals(expected.protectionElement, actual.protectionElement); for (int i = 0; i < expected.streamElements.length; i++) { StreamElement expectedStreamElement = expected.streamElements[i]; StreamElement actualStreamElement = actual.streamElements[i]; assertEquals(expectedStreamElement.chunkCount, actualStreamElement.chunkCount); assertEquals(expectedStreamElement.displayHeight, actualStreamElement.displayHeight); assertEquals(expectedStreamElement.displayWidth, actualStreamElement.displayWidth); assertEquals(expectedStreamElement.language, actualStreamElement.language); assertEquals(expectedStreamElement.maxHeight, actualStreamElement.maxHeight); assertEquals(expectedStreamElement.maxWidth, actualStreamElement.maxWidth); assertEquals(expectedStreamElement.name, actualStreamElement.name); assertEquals(expectedStreamElement.subType, actualStreamElement.subType); assertEquals(expectedStreamElement.timescale, actualStreamElement.timescale); assertEquals(expectedStreamElement.type, actualStreamElement.type); MoreAsserts.assertEquals(expectedStreamElement.formats, actualStreamElement.formats); } }