/*
* Copyright 2009 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.core.client.impl;
import com.google.gwt.core.client.impl.AsyncFragmentLoader.LoadTerminatedHandler;
import com.google.gwt.core.client.impl.AsyncFragmentLoader.LoadingStrategy;
import com.google.gwt.core.client.impl.AsyncFragmentLoader.Logger;
import junit.framework.TestCase;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
/**
* Tests that the fragment loader requests the right fragments and logs the
* correct lightweight metrics under a variety of request patterns.
*/
public class AsyncFragmentLoaderTest extends TestCase {
private static class MockErrorHandler implements LoadTerminatedHandler {
private boolean wasCalled = false;
public boolean getWasCalled() {
return wasCalled;
}
public void loadTerminated(Throwable reason) {
wasCalled = true;
}
}
private static class MockLoadStrategy implements LoadingStrategy {
public final Map<Integer, LoadTerminatedHandler> errorHandlers = new HashMap<Integer, LoadTerminatedHandler>();
private List<Integer> loadRequests = new LinkedList<Integer>();
public void assertFragmentsRequested(int... expectedAry) {
List<Integer> actual = new ArrayList<Integer>(loadRequests);
loadRequests.clear();
List<Integer> expected = toList(expectedAry);
if (!sameContents(actual, expected)) {
fail("Expected= " + commaSeparated(expected) + "; actual="
+ commaSeparated(actual));
}
}
public void startLoadingFragment(int fragment,
LoadTerminatedHandler loadErrorHandler) {
errorHandlers.put(fragment, loadErrorHandler);
loadRequests.add(fragment);
}
private String commaSeparated(List<Integer> ary) {
StringBuilder sb = new StringBuilder();
boolean first = true;
for (Integer x : ary) {
if (first) {
first = false;
} else {
sb.append(",");
}
sb.append(x);
}
return sb.toString();
}
private boolean sameContents(List<Integer> actual, List<Integer> expected) {
if (actual.size() != expected.size()) {
return false;
}
for (int i = 0; i < actual.size(); i++) {
if (!actual.get(i).equals(expected.get(i))) {
return false;
}
}
return true;
}
private List<Integer> toList(int[] ary) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < ary.length; i++) {
list.add(ary[i]);
}
return list;
}
}
private static class MockProgressEvent {
public final String eventGroup;
public final int fragment;
public final String type;
public MockProgressEvent(String eventGroup, String type, int fragment) {
this.eventGroup = eventGroup;
this.type = type;
this.fragment = fragment;
}
}
private static class MockProgressLogger implements Logger {
private Queue<MockProgressEvent> events = new LinkedList<MockProgressEvent>();
public void assertEvent(String eventGroup, String type, int fragment) {
MockProgressEvent event = events.remove();
assertEquals(eventGroup, event.eventGroup);
assertEquals(type, event.type);
assertEquals(fragment, event.fragment);
}
public void assertNoEvents() {
assertTrue("Expected no more progress events, but there are "
+ events.size(), events.size() == 0);
}
public void logEventProgress(String eventGroup, String type,
int fragment, int size) {
events.add(new MockProgressEvent(eventGroup, type, fragment));
}
}
private static final String BEGIN = "begin";
private static final String END = "end";
private static final String LEFTOVERS_DOWNLOAD = "leftoversDownload";
private static final LoadTerminatedHandler NULL_ERROR_HANDLER = new LoadTerminatedHandler() {
public void loadTerminated(Throwable reason) {
}
};
private static Throwable makeLoadFailedException() {
return new RuntimeException("Load Failed");
}
public void testBasics() {
MockLoadStrategy reqs = new MockLoadStrategy();
MockProgressLogger progress = new MockProgressLogger();
int numEntries = 5;
AsyncFragmentLoader loader = new AsyncFragmentLoader(numEntries,
new int[] {}, reqs, progress);
loader.inject(1, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(numEntries);
progress.assertEvent(LEFTOVERS_DOWNLOAD, BEGIN, numEntries);
loader.leftoversFragmentHasLoaded();
reqs.assertFragmentsRequested(1);
progress.assertEvent(LEFTOVERS_DOWNLOAD, END, numEntries);
progress.assertEvent("download1", BEGIN, 1);
loader.fragmentHasLoaded(1);
progress.assertEvent("download1", END, 1);
loader.inject(2, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(2);
progress.assertEvent("download2", BEGIN, 2);
loader.fragmentHasLoaded(2);
progress.assertEvent("download2", END, 2);
progress.assertNoEvents();
}
/**
* Check the behavior when there are download failures.
*/
public void testDownloadFailures() {
MockLoadStrategy reqs = new MockLoadStrategy();
MockProgressLogger progress = new MockProgressLogger();
int numEntries = 10;
AsyncFragmentLoader loader = new AsyncFragmentLoader(numEntries, new int[] {
1, 2, 3}, reqs, progress);
// request fragment 1
MockErrorHandler error1try1 = new MockErrorHandler();
loader.inject(1, error1try1);
reqs.assertFragmentsRequested(1);
progress.assertEvent("download1", BEGIN, 1);
// fragment 1 fails
loadFailed(reqs, 1);
assertTrue(error1try1.getWasCalled());
// try again on fragment 1
MockErrorHandler error1try2 = new MockErrorHandler();
loader.inject(1, error1try2);
reqs.assertFragmentsRequested(1);
progress.assertEvent("download1", BEGIN, 1);
// this time fragment 1 succeeds
loader.fragmentHasLoaded(1);
reqs.assertFragmentsRequested();
assertFalse(error1try2.getWasCalled());
progress.assertEvent("download1", END, 1);
// request a later initial fragment (3), and see what happens if an
// intermediate download fails
MockErrorHandler error3try1 = new MockErrorHandler();
loader.inject(3, error3try1);
reqs.assertFragmentsRequested(2);
progress.assertEvent("download2", BEGIN, 2);
loadFailed(reqs, 2);
assertTrue(error3try1.wasCalled);
// request both 3 and 5, and see what happens if
// the leftovers download fails
MockErrorHandler error3try2 = new MockErrorHandler();
MockErrorHandler error5try1 = new MockErrorHandler();
loader.inject(3, error3try2);
loader.inject(5, error5try1);
reqs.assertFragmentsRequested(2);
progress.assertEvent("download2", BEGIN, 2);
loader.fragmentHasLoaded(2);
reqs.assertFragmentsRequested(3);
progress.assertEvent("download2", END, 2);
progress.assertEvent("download3", BEGIN, 3);
loader.fragmentHasLoaded(3);
reqs.assertFragmentsRequested(numEntries);
progress.assertEvent("download3", END, 3);
progress.assertEvent(LEFTOVERS_DOWNLOAD, BEGIN, numEntries);
loadFailed(reqs, numEntries); // leftovers fails!
assertFalse(error3try2.getWasCalled()); // 3 should have succeeded
assertTrue(error5try1.getWasCalled()); // 5 failed
// now try 5 again, and have everything succeed
MockErrorHandler error5try2 = new MockErrorHandler();
loader.inject(5, error5try2);
reqs.assertFragmentsRequested(numEntries);
progress.assertEvent(LEFTOVERS_DOWNLOAD, BEGIN, numEntries);
loader.leftoversFragmentHasLoaded();
reqs.assertFragmentsRequested(5);
progress.assertEvent(LEFTOVERS_DOWNLOAD, END, numEntries);
progress.assertEvent("download5", BEGIN, 5);
loader.fragmentHasLoaded(5);
reqs.assertFragmentsRequested();
assertFalse(error5try2.getWasCalled());
progress.assertEvent("download5", END, 5);
// try 6 but have it fail
MockErrorHandler error6try1 = new MockErrorHandler();
loader.inject(6, error6try1);
reqs.assertFragmentsRequested(6);
progress.assertEvent("download6", BEGIN, 6);
loadFailed(reqs, 6);
assertTrue(error6try1.getWasCalled());
// try 7 and have it succeed
loader.inject(7, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(7);
progress.assertEvent("download7", BEGIN, 7);
loader.fragmentHasLoaded(7);
reqs.assertFragmentsRequested();
progress.assertEvent("download7", END, 7);
// try 6 again and have it succeed this time
MockErrorHandler error6try2 = new MockErrorHandler();
loader.inject(6, error6try2);
reqs.assertFragmentsRequested(6);
progress.assertEvent("download6", BEGIN, 6);
loader.fragmentHasLoaded(6);
reqs.assertFragmentsRequested();
assertFalse(error6try2.getWasCalled());
progress.assertEvent("download6", END, 6);
// a finish event should do nothing if the fragment has already succeeded
progress.assertNoEvents();
loadFailed(reqs, 6);
assertFalse(error6try2.getWasCalled());
progress.assertNoEvents();
}
public void testExclusivesLoadSequentially1() {
MockLoadStrategy reqs = new MockLoadStrategy();
MockProgressLogger progress = new MockProgressLogger();
int numEntries = 6;
AsyncFragmentLoader loader = new AsyncFragmentLoader(numEntries,
new int[] {}, reqs, progress);
// Load fragment 1
loader.inject(1, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(numEntries); // leftovers
progress.assertEvent("leftoversDownload", BEGIN, numEntries);
loader.fragmentHasLoaded(numEntries);
reqs.assertFragmentsRequested(1);
progress.assertEvent("leftoversDownload", END, numEntries);
progress.assertEvent("download1", BEGIN, 1);
loader.fragmentHasLoaded(1);
progress.assertEvent("download1", END, 1);
progress.assertNoEvents();
// Request 2 and 3 immediately
loader.inject(2, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(2);
progress.assertEvent("download2", BEGIN, 2);
loader.inject(3, NULL_ERROR_HANDLER);
progress.assertNoEvents(); // waiting on 2 to finish
// 2 loads, 3 should be requested
loader.fragmentHasLoaded(2);
reqs.assertFragmentsRequested(3);
progress.assertEvent("download2", END, 2);
progress.assertEvent("download3", BEGIN, 3);
progress.assertNoEvents();
// 3 loads
loader.fragmentHasLoaded(3);
progress.assertEvent("download3", END, 3);
progress.assertNoEvents();
}
public void testExclusivesLoadSequentially2() {
MockLoadStrategy reqs = new MockLoadStrategy();
MockProgressLogger progress = new MockProgressLogger();
int numEntries = 6;
AsyncFragmentLoader loader = new AsyncFragmentLoader(numEntries,
new int[] {}, reqs, progress);
// Request 1
loader.inject(1, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(numEntries);
progress.assertEvent("leftoversDownload", BEGIN, numEntries);
// Request 2, resulting in two fragments being queued behind the leftovers
// download
loader.inject(2, NULL_ERROR_HANDLER);
progress.assertNoEvents();
// Leftovers arrives, but only fragment 1 should initially be requested
loader.leftoversFragmentHasLoaded();
reqs.assertFragmentsRequested(1);
progress.assertEvent("leftoversDownload", END, numEntries);
progress.assertEvent("download1", BEGIN, 1);
progress.assertNoEvents();
// fragment 1 arrives, 2 requested
loader.fragmentHasLoaded(1);
reqs.assertFragmentsRequested(2);
progress.assertEvent("download1", END, 1);
progress.assertEvent("download2", BEGIN, 2);
// fragment 2 arrives, all done
loader.fragmentHasLoaded(2);
progress.assertEvent("download2", END, 2);
progress.assertNoEvents();
}
/**
* If only the first part of the initial load sequence is requested, then
* don't request more.
*/
public void testLoadingPartOfInitialSequence() {
MockLoadStrategy reqs = new MockLoadStrategy();
MockProgressLogger progress = new MockProgressLogger();
int numEntries = 6;
AsyncFragmentLoader loader = new AsyncFragmentLoader(numEntries, new int[] {
1, 2, 3}, reqs, progress);
loader.inject(1, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(1);
progress.assertEvent("download1", BEGIN, 1);
loader.fragmentHasLoaded(1);
reqs.assertFragmentsRequested(); // should stop
progress.assertEvent("download1", END, 1);
loader.inject(2, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(2);
progress.assertEvent("download2", BEGIN, 2);
loader.fragmentHasLoaded(2);
reqs.assertFragmentsRequested(); // again, should stop
progress.assertEvent("download2", END, 2);
loader.inject(3, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(3);
progress.assertEvent("download3", BEGIN, 3);
loader.fragmentHasLoaded(3);
reqs.assertFragmentsRequested();
progress.assertEvent("download3", END, 3);
progress.assertNoEvents();
// check that exclusives now load
loader.inject(5, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(numEntries);
progress.assertEvent(LEFTOVERS_DOWNLOAD, BEGIN, numEntries);
loader.fragmentHasLoaded(numEntries);
reqs.assertFragmentsRequested(5);
progress.assertEvent(LEFTOVERS_DOWNLOAD, END, numEntries);
progress.assertEvent("download5", BEGIN, 5);
loader.fragmentHasLoaded(5);
reqs.assertFragmentsRequested();
progress.assertEvent("download5", END, 5);
progress.assertNoEvents();
}
/**
* This test catches a case in an earlier version of AsyncFragmentLoader where
* AsyncFragmentLoader.waitingForInitialFragments could exhaust its available
* space.
*/
public void testOverflowInWaitingForInitialFragments() {
MockLoadStrategy reqs = new MockLoadStrategy();
MockProgressLogger progress = new MockProgressLogger();
int numEntries = 6;
AsyncFragmentLoader loader = new AsyncFragmentLoader(numEntries, new int[] {
1, 2, 3}, reqs, progress);
/*
* Repeatedly queue up extra downloads waiting on an initial and then fail.
*/
for (int i = 0; i < 10; i++) {
MockErrorHandler error = new MockErrorHandler();
loader.inject(4, error);
reqs.assertFragmentsRequested(1);
progress.assertEvent("download1", BEGIN, 1);
loadFailed(reqs, 1);
assertTrue(error.getWasCalled());
progress.assertNoEvents();
}
}
public void testPrefetch() {
MockLoadStrategy reqs = new MockLoadStrategy();
MockProgressLogger progress = new MockProgressLogger();
int numEntries = 20;
AsyncFragmentLoader loader = new AsyncFragmentLoader(numEntries, new int[] {
1, 2, 3}, reqs, progress);
loader.startPrefetching();
// request a prefetch of something in the initial load sequence
loader.setPrefetchQueue(2);
reqs.assertFragmentsRequested(1);
progress.assertEvent("download1", BEGIN, 1);
loader.fragmentHasLoaded(1);
reqs.assertFragmentsRequested(2);
progress.assertEvent("download1", END, 1);
progress.assertEvent("download2", BEGIN, 2);
loader.fragmentHasLoaded(2);
reqs.assertFragmentsRequested();
progress.assertEvent("download2", END, 2);
progress.assertNoEvents();
// request a prefetch of an exclusive
loader.setPrefetchQueue(4);
reqs.assertFragmentsRequested(3);
progress.assertEvent("download3", BEGIN, 3);
loader.fragmentHasLoaded(3);
reqs.assertFragmentsRequested(numEntries);
progress.assertEvent("download3", END, 3);
progress.assertEvent("leftoversDownload", BEGIN, numEntries);
loader.leftoversFragmentHasLoaded();
reqs.assertFragmentsRequested(4);
progress.assertEvent("leftoversDownload", END, numEntries);
progress.assertEvent("download4", BEGIN, 4);
loader.fragmentHasLoaded(4);
reqs.assertFragmentsRequested();
progress.assertEvent("download4", END, 4);
progress.assertNoEvents();
// request a prefetch, but check that an inject call takes priority
loader.setPrefetchQueue(5, 6);
reqs.assertFragmentsRequested(5);
progress.assertEvent("download5", BEGIN, 5);
loader.inject(7, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested();
progress.assertNoEvents();
loader.fragmentHasLoaded(5);
reqs.assertFragmentsRequested(7);
progress.assertEvent("download5", END, 5);
progress.assertEvent("download7", BEGIN, 7);
loader.fragmentHasLoaded(7);
reqs.assertFragmentsRequested(6);
progress.assertEvent("download7", END, 7);
progress.assertEvent("download6", BEGIN, 6);
loader.fragmentHasLoaded(6);
reqs.assertFragmentsRequested();
progress.assertEvent("download6", END, 6);
progress.assertNoEvents();
// request prefetches, then request different prefetches
loader.setPrefetchQueue(8, 9);
reqs.assertFragmentsRequested(8);
progress.assertEvent("download8", BEGIN, 8);
loader.setPrefetchQueue(10);
reqs.assertFragmentsRequested();
progress.assertNoEvents();
loader.fragmentHasLoaded(8);
reqs.assertFragmentsRequested(10);
progress.assertEvent("download8", END, 8);
progress.assertEvent("download10", BEGIN, 10);
loader.fragmentHasLoaded(10);
reqs.assertFragmentsRequested();
progress.assertEvent("download10", END, 10);
progress.assertNoEvents();
// request prefetches that have already been loaded
loader.setPrefetchQueue(1, 3, 7, 10);
reqs.assertFragmentsRequested();
progress.assertNoEvents();
}
/**
* Prefetch initial split points out of order.
*/
public void testPrefetchInitialsOutOfOrder() {
MockLoadStrategy reqs = new MockLoadStrategy();
MockProgressLogger progress = new MockProgressLogger();
int numEntries = 20;
AsyncFragmentLoader loader = new AsyncFragmentLoader(numEntries, new int[] {
1, 2, 3}, reqs, progress);
loader.startPrefetching();
// request a prefetch of something in the initial load sequence
loader.setPrefetchQueue(3, 2, 1);
reqs.assertFragmentsRequested(1);
progress.assertEvent("download1", BEGIN, 1);
loader.fragmentHasLoaded(1);
reqs.assertFragmentsRequested(2);
progress.assertEvent("download1", END, 1);
progress.assertEvent("download2", BEGIN, 2);
loader.fragmentHasLoaded(2);
reqs.assertFragmentsRequested(3);
progress.assertEvent("download2", END, 2);
progress.assertEvent("download3", BEGIN, 3);
loader.fragmentHasLoaded(3);
progress.assertEvent("download3", END, 3);
reqs.assertFragmentsRequested();
progress.assertNoEvents();
// check that the loader is in a sane state by downloading an exclusive
loader.inject(5, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(numEntries);
progress.assertEvent("leftoversDownload", BEGIN, numEntries);
loader.leftoversFragmentHasLoaded();
reqs.assertFragmentsRequested(5);
progress.assertEvent("leftoversDownload", END, numEntries);
progress.assertEvent("download5", BEGIN, 5);
loader.fragmentHasLoaded(5);
reqs.assertFragmentsRequested();
progress.assertEvent("download5", END, 5);
progress.assertNoEvents();
}
/**
* Test that no prefetching happens if prefetching is turned off.
*/
public void testPrefetchingDisabled() {
MockLoadStrategy reqs = new MockLoadStrategy();
MockProgressLogger progress = new MockProgressLogger();
int numEntries = 20;
AsyncFragmentLoader loader = new AsyncFragmentLoader(numEntries,
new int[] {}, reqs, progress);
loader.stopPrefetching();
// Prefetch 1, but leave prefetching off
loader.setPrefetchQueue(1);
reqs.assertFragmentsRequested();
progress.assertNoEvents();
// Inject 2, which should lead to leftovers and 2 loading
loader.inject(2, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(numEntries);
progress.assertEvent("leftoversDownload", BEGIN, numEntries);
loader.leftoversFragmentHasLoaded();
reqs.assertFragmentsRequested(2);
progress.assertEvent("leftoversDownload", END, numEntries);
progress.assertEvent("download2", BEGIN, 2);
loader.fragmentHasLoaded(2);
reqs.assertFragmentsRequested();
progress.assertEvent("download2", END, 2);
progress.assertNoEvents();
// Enable prefetching; now 1 should load
loader.startPrefetching();
reqs.assertFragmentsRequested(1);
progress.assertEvent("download1", BEGIN, 1);
loader.fragmentHasLoaded(1);
reqs.assertFragmentsRequested();
progress.assertEvent("download1", END, 1);
progress.assertNoEvents();
}
/**
* Test prefetching an item and then injecting it while the prefetch is in
* progress.
*/
public void testPrefetchThenInjectOfSame() {
MockLoadStrategy reqs = new MockLoadStrategy();
MockProgressLogger progress = new MockProgressLogger();
int numEntries = 20;
AsyncFragmentLoader loader = new AsyncFragmentLoader(numEntries,
new int[] {}, reqs, progress);
loader.startPrefetching();
// Load the leftovers and one fragment
loader.inject(1, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(numEntries);
progress.assertEvent("leftoversDownload", BEGIN, numEntries);
loader.leftoversFragmentHasLoaded();
reqs.assertFragmentsRequested(1);
progress.assertEvent("leftoversDownload", END, numEntries);
progress.assertEvent("download1", BEGIN, 1);
loader.fragmentHasLoaded(1);
reqs.assertFragmentsRequested();
progress.assertEvent("download1", END, 1);
progress.assertNoEvents();
// Start prefetching a fragment
loader.setPrefetchQueue(2);
reqs.assertFragmentsRequested(2);
progress.assertEvent("download2", BEGIN, 2);
// Inject the same fragment and another one
loader.inject(2, NULL_ERROR_HANDLER);
loader.inject(3, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested();
progress.assertNoEvents();
// Finish the fragment loads
loader.fragmentHasLoaded(2);
reqs.assertFragmentsRequested(3);
progress.assertEvent("download2", END, 2);
progress.assertEvent("download3", BEGIN, 3);
loader.fragmentHasLoaded(3);
reqs.assertFragmentsRequested();
progress.assertEvent("download3", END, 3);
progress.assertNoEvents();
}
/**
* A thorough exercise of loading with an initial load sequence specified.
*/
public void testWithInitialLoadSequence() {
MockLoadStrategy reqs = new MockLoadStrategy();
MockProgressLogger progress = new MockProgressLogger();
int numEntries = 6;
AsyncFragmentLoader loader = new AsyncFragmentLoader(numEntries, new int[] {
1, 2, 3}, reqs, progress);
loader.inject(1, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(1);
progress.assertEvent("download1", BEGIN, 1);
loader.inject(3, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(); // still waiting on fragment 1
progress.assertNoEvents();
loader.inject(5, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(); // still waiting on fragment 1
progress.assertNoEvents();
// say that 1 loads, which should trigger a chain of backlogged downloads
loader.fragmentHasLoaded(1);
reqs.assertFragmentsRequested(2); // next initial
progress.assertEvent("download1", END, 1);
progress.assertEvent("download2", BEGIN, 2);
loader.fragmentHasLoaded(2);
reqs.assertFragmentsRequested(3); // next initial
progress.assertEvent("download2", END, 2);
progress.assertEvent("download3", BEGIN, 3);
loader.fragmentHasLoaded(3);
reqs.assertFragmentsRequested(numEntries); // leftovers
progress.assertEvent("download3", END, 3);
progress.assertEvent("leftoversDownload", BEGIN, numEntries);
loader.leftoversFragmentHasLoaded();
reqs.assertFragmentsRequested(5);
progress.assertEvent("leftoversDownload", END, numEntries);
progress.assertEvent("download5", BEGIN, 5);
loader.fragmentHasLoaded(5);
reqs.assertFragmentsRequested(); // quiescent
progress.assertEvent("download5", END, 5);
progress.assertNoEvents();
// check that new exclusive fragment requests work
loader.inject(4, NULL_ERROR_HANDLER);
reqs.assertFragmentsRequested(4);
progress.assertEvent("download4", BEGIN, 4);
loader.fragmentHasLoaded(4);
reqs.assertFragmentsRequested();
progress.assertEvent("download4", END, 4);
progress.assertNoEvents();
}
private void loadFailed(MockLoadStrategy reqs, int fragment) {
reqs.errorHandlers.get(fragment).loadTerminated(makeLoadFailedException());
}
}