method2testcases stringlengths 118 6.63k |
|---|
### Question:
DownloadDispatcher { public static void setMaxParallelRunningCount(int maxParallelRunningCount) { DownloadDispatcher dispatcher = OkDownload.with().downloadDispatcher(); if (dispatcher.getClass() != DownloadDispatcher.class) { throw new IllegalStateException( "The current dispatcher is " + dispatcher + " not DownloadDispatcher exactly!"); } maxParallelRunningCount = Math.max(1, maxParallelRunningCount); dispatcher.maxParallelRunningCount = maxParallelRunningCount; } DownloadDispatcher(); DownloadDispatcher(List<DownloadCall> readyAsyncCalls,
List<DownloadCall> runningAsyncCalls,
List<DownloadCall> runningSyncCalls,
List<DownloadCall> finishingCalls); void setDownloadStore(@NonNull DownloadStore store); void enqueue(DownloadTask[] tasks); void enqueue(DownloadTask task); void execute(DownloadTask task); @SuppressWarnings("PMD.ForLoopsMustUseBraces") void cancelAll(); void cancel(IdentifiedTask[] tasks); boolean cancel(IdentifiedTask task); boolean cancel(int id); @Nullable synchronized DownloadTask findSameTask(DownloadTask task); synchronized boolean isRunning(DownloadTask task); synchronized boolean isPending(DownloadTask task); synchronized void flyingCanceled(DownloadCall call); synchronized void finish(DownloadCall call); synchronized boolean isFileConflictAfterRun(@NonNull DownloadTask task); static void setMaxParallelRunningCount(int maxParallelRunningCount); }### Answer:
@Test public void setMaxParallelRunningCount() { doReturn(mock(MockDownloadDispatcher.class)).when(OkDownload.with()).downloadDispatcher(); thrown.expect(IllegalStateException.class); DownloadDispatcher.setMaxParallelRunningCount(1); doReturn(dispatcher).when(OkDownload.with()).breakpointStore(); DownloadDispatcher.setMaxParallelRunningCount(0); assertThat(dispatcher.maxParallelRunningCount).isEqualTo(1); DownloadDispatcher.setMaxParallelRunningCount(2); assertThat(dispatcher.maxParallelRunningCount).isEqualTo(2); } |
### Question:
DownloadDispatcher { boolean inspectCompleted(@NonNull DownloadTask task) { return inspectCompleted(task, null); } DownloadDispatcher(); DownloadDispatcher(List<DownloadCall> readyAsyncCalls,
List<DownloadCall> runningAsyncCalls,
List<DownloadCall> runningSyncCalls,
List<DownloadCall> finishingCalls); void setDownloadStore(@NonNull DownloadStore store); void enqueue(DownloadTask[] tasks); void enqueue(DownloadTask task); void execute(DownloadTask task); @SuppressWarnings("PMD.ForLoopsMustUseBraces") void cancelAll(); void cancel(IdentifiedTask[] tasks); boolean cancel(IdentifiedTask task); boolean cancel(int id); @Nullable synchronized DownloadTask findSameTask(DownloadTask task); synchronized boolean isRunning(DownloadTask task); synchronized boolean isPending(DownloadTask task); synchronized void flyingCanceled(DownloadCall call); synchronized void finish(DownloadCall call); synchronized boolean isFileConflictAfterRun(@NonNull DownloadTask task); static void setMaxParallelRunningCount(int maxParallelRunningCount); }### Answer:
@Test public void inspectCompleted() throws IOException { mockOkDownload(); final CallbackDispatcher callbackDispatcher = OkDownload.with().callbackDispatcher(); final DownloadTask task = mock(DownloadTask.class); when(task.isPassIfAlreadyCompleted()).thenReturn(true); when(task.getId()).thenReturn(0); when(task.getUrl()).thenReturn("url"); when(task.getParentFile()).thenReturn(existFile.getParentFile()); final BreakpointStore store = OkDownload.with().breakpointStore(); doReturn(existFile.getName()).when(store).getResponseFilename("url"); final DownloadStrategy downloadStrategy = OkDownload.with().downloadStrategy(); doReturn(false).when(downloadStrategy).validFilenameFromStore(task); assertThat(dispatcher.inspectCompleted(task)).isFalse(); verify(callbackDispatcher, never()).dispatch(); doReturn(true).when(downloadStrategy).validFilenameFromStore(task); assertThat(dispatcher.inspectCompleted(task)).isTrue(); final DownloadListener listener = callbackDispatcher.dispatch(); verify(listener).taskEnd(eq(task), eq(EndCause.COMPLETED), nullable(Exception.class)); verify(downloadStrategy).validInfoOnCompleted(eq(task), eq(this.store)); }
@Test public void inspectCompleted_collection() throws IOException { mockOkDownload(); final DownloadStrategy downloadStrategy = OkDownload.with().downloadStrategy(); final CallbackDispatcher callbackDispatcher = OkDownload.with().callbackDispatcher(); final DownloadListener listener = callbackDispatcher.dispatch(); final DownloadTask task = mock(DownloadTask.class); when(task.isPassIfAlreadyCompleted()).thenReturn(true); when(task.getId()).thenReturn(0); when(task.getUrl()).thenReturn("url"); when(task.getParentFile()).thenReturn(existFile.getParentFile()); final BreakpointStore store = OkDownload.with().breakpointStore(); doReturn(existFile.getName()).when(store).getResponseFilename("url"); doReturn(true).when(downloadStrategy).validFilenameFromStore(task); final Collection<DownloadTask> completedCollection = new ArrayList<>(); assertThat(dispatcher.inspectCompleted(task, completedCollection)).isTrue(); verify(listener, never()).taskEnd(eq(task), any(EndCause.class), nullable(Exception.class)); assertThat(completedCollection).containsExactly(task); } |
### Question:
DownloadDispatcher { private boolean inspectForConflict(@NonNull DownloadTask task) { return inspectForConflict(task, null, null); } DownloadDispatcher(); DownloadDispatcher(List<DownloadCall> readyAsyncCalls,
List<DownloadCall> runningAsyncCalls,
List<DownloadCall> runningSyncCalls,
List<DownloadCall> finishingCalls); void setDownloadStore(@NonNull DownloadStore store); void enqueue(DownloadTask[] tasks); void enqueue(DownloadTask task); void execute(DownloadTask task); @SuppressWarnings("PMD.ForLoopsMustUseBraces") void cancelAll(); void cancel(IdentifiedTask[] tasks); boolean cancel(IdentifiedTask task); boolean cancel(int id); @Nullable synchronized DownloadTask findSameTask(DownloadTask task); synchronized boolean isRunning(DownloadTask task); synchronized boolean isPending(DownloadTask task); synchronized void flyingCanceled(DownloadCall call); synchronized void finish(DownloadCall call); synchronized boolean isFileConflictAfterRun(@NonNull DownloadTask task); static void setMaxParallelRunningCount(int maxParallelRunningCount); }### Answer:
@Test public void inspectForConflict_sameTask() throws IOException { mockOkDownload(); final CallbackDispatcher callbackDispatcher = OkDownload.with().callbackDispatcher(); final DownloadListener listener = callbackDispatcher.dispatch(); DownloadTask task = mock(DownloadTask.class); final Collection<DownloadCall> calls = new ArrayList<>(); final Collection<DownloadTask> sameTaskList = new ArrayList<>(); final Collection<DownloadTask> fileBusyList = new ArrayList<>(); final DownloadCall call = mock(DownloadCall.class); when(call.equalsTask(task)).thenReturn(true); calls.add(call); assertThat(dispatcher.inspectForConflict(task, calls, sameTaskList, fileBusyList)).isTrue(); assertThat(sameTaskList).containsExactly(task); assertThat(fileBusyList).isEmpty(); verify(listener, never()).taskEnd(eq(task), any(EndCause.class), nullable(Exception.class)); }
@Test public void inspectForConflict_sameTask_isFinishing() { final DownloadTask task = mock(DownloadTask.class); final DownloadCall call = mock(DownloadCall.class); when(call.equalsTask(task)).thenReturn(true); when(call.isFinishing()).thenReturn(true); final Collection<DownloadCall> calls = new ArrayList<>(); final Collection<DownloadTask> sameTaskList = new ArrayList<>(); final Collection<DownloadTask> fileBusyList = new ArrayList<>(); calls.add(call); assertThat(dispatcher.inspectForConflict(task, calls, sameTaskList, fileBusyList)) .isFalse(); assertThat(fileBusyList).isEmpty(); assertThat(sameTaskList).isEmpty(); assertThat(finishingCalls).hasSize(1); }
@Test public void inspectForConflict_fileBusy() throws IOException { mockOkDownload(); final CallbackDispatcher callbackDispatcher = OkDownload.with().callbackDispatcher(); final DownloadListener listener = callbackDispatcher.dispatch(); DownloadTask task = mock(DownloadTask.class); final Collection<DownloadCall> calls = new ArrayList<>(); final Collection<DownloadTask> sameTaskList = new ArrayList<>(); final Collection<DownloadTask> fileBusyList = new ArrayList<>(); final DownloadCall call = mock(DownloadCall.class); final File file = mock(File.class); when(task.getFile()).thenReturn(file); when(call.getFile()).thenReturn(file); calls.add(call); assertThat(dispatcher.inspectForConflict(task, calls, sameTaskList, fileBusyList)).isTrue(); assertThat(sameTaskList).isEmpty(); assertThat(fileBusyList).containsExactly(task); verify(listener, never()).taskEnd(eq(task), any(EndCause.class), nullable(Exception.class)); } |
### Question:
DownloadDispatcher { @Nullable public synchronized DownloadTask findSameTask(DownloadTask task) { Util.d(TAG, "findSameTask: " + task.getId()); for (DownloadCall call : readyAsyncCalls) { if (call.isCanceled()) continue; if (call.equalsTask(task)) return call.task; } for (DownloadCall call : runningAsyncCalls) { if (call.isCanceled()) continue; if (call.equalsTask(task)) return call.task; } for (DownloadCall call : runningSyncCalls) { if (call.isCanceled()) continue; if (call.equalsTask(task)) return call.task; } return null; } DownloadDispatcher(); DownloadDispatcher(List<DownloadCall> readyAsyncCalls,
List<DownloadCall> runningAsyncCalls,
List<DownloadCall> runningSyncCalls,
List<DownloadCall> finishingCalls); void setDownloadStore(@NonNull DownloadStore store); void enqueue(DownloadTask[] tasks); void enqueue(DownloadTask task); void execute(DownloadTask task); @SuppressWarnings("PMD.ForLoopsMustUseBraces") void cancelAll(); void cancel(IdentifiedTask[] tasks); boolean cancel(IdentifiedTask task); boolean cancel(int id); @Nullable synchronized DownloadTask findSameTask(DownloadTask task); synchronized boolean isRunning(DownloadTask task); synchronized boolean isPending(DownloadTask task); synchronized void flyingCanceled(DownloadCall call); synchronized void finish(DownloadCall call); synchronized boolean isFileConflictAfterRun(@NonNull DownloadTask task); static void setMaxParallelRunningCount(int maxParallelRunningCount); }### Answer:
@Test public void findSameTask_readyAsyncCall() { final DownloadTask task = mock(DownloadTask.class); final DownloadStore store = mock(DownloadStore.class); final DownloadCall canceledCall = spy(DownloadCall .create(mock(DownloadTask.class), true, store)); final DownloadCall nonCanceledCall = spy(DownloadCall .create(mock(DownloadTask.class), true, store)); when(canceledCall.isCanceled()).thenReturn(true); when(canceledCall.equalsTask(task)).thenReturn(true); when(nonCanceledCall.equalsTask(task)).thenReturn(true); readyAsyncCalls.add(canceledCall); readyAsyncCalls.add(nonCanceledCall); assertThat(dispatcher.findSameTask(task)).isEqualTo(nonCanceledCall.task); }
@Test public void findSameTask_runningAsyncCall() { final DownloadTask task = mock(DownloadTask.class); final DownloadStore store = mock(DownloadStore.class); final DownloadCall canceledCall = spy(DownloadCall .create(mock(DownloadTask.class), true, store)); final DownloadCall nonCanceledCall = spy(DownloadCall .create(mock(DownloadTask.class), true, store)); when(canceledCall.equalsTask(task)).thenReturn(true); when(canceledCall.isCanceled()).thenReturn(true); when(nonCanceledCall.equalsTask(task)).thenReturn(true); runningAsyncCalls.add(canceledCall); runningAsyncCalls.add(nonCanceledCall); assertThat(dispatcher.findSameTask(task)).isEqualTo(nonCanceledCall.task); }
@Test public void findSameTask_runningSyncCall() { final DownloadTask task = mock(DownloadTask.class); final DownloadStore store = mock(DownloadStore.class); final DownloadCall canceledCall = spy(DownloadCall .create(mock(DownloadTask.class), false, store)); final DownloadCall nonCanceledCall = spy(DownloadCall .create(mock(DownloadTask.class), false, store)); when(canceledCall.isCanceled()).thenReturn(true); when(canceledCall.equalsTask(task)).thenReturn(true); when(nonCanceledCall.equalsTask(task)).thenReturn(true); runningSyncCalls.add(canceledCall); runningSyncCalls.add(nonCanceledCall); assertThat(dispatcher.findSameTask(task)).isEqualTo(nonCanceledCall.task); }
@Test public void findSameTask_nonMatch() { final DownloadTask task = mock(DownloadTask.class); assertThat(dispatcher.findSameTask(task)).isNull(); } |
### Question:
SpeedCalculator { public String speed() { return humanReadableSpeed(getBytesPerSecondAndFlush(), true); } synchronized void reset(); synchronized void downloading(long increaseBytes); synchronized void flush(); long getInstantBytesPerSecondAndFlush(); synchronized long getBytesPerSecondAndFlush(); synchronized long getBytesPerSecondFromBegin(); synchronized void endTask(); String instantSpeed(); String speed(); String lastSpeed(); synchronized long getInstantSpeedDurationMillis(); String getSpeedWithBinaryAndFlush(); String getSpeedWithSIAndFlush(); String averageSpeed(); String speedFromBegin(); }### Answer:
@Test public void speed() { long now = 66; doReturn(now).when(calculator).nowMillis(); calculator.downloading(1000); now = 565; doReturn(now).when(calculator).nowMillis(); assertThat(calculator.speed()).isEqualTo("0 B/s"); now = 566; doReturn(now).when(calculator).nowMillis(); assertThat(calculator.speed()).isEqualTo("2.0 kB/s"); now = 1066; doReturn(now).when(calculator).nowMillis(); assertThat(calculator.speed()).isEqualTo("2.0 kB/s"); } |
### Question:
DownloadDispatcher { public synchronized boolean isRunning(DownloadTask task) { Util.d(TAG, "isRunning: " + task.getId()); for (DownloadCall call : runningSyncCalls) { if (call.isCanceled()) continue; if (call.equalsTask(task)) { return true; } } for (DownloadCall call : runningAsyncCalls) { if (call.isCanceled()) continue; if (call.equalsTask(task)) { return true; } } return false; } DownloadDispatcher(); DownloadDispatcher(List<DownloadCall> readyAsyncCalls,
List<DownloadCall> runningAsyncCalls,
List<DownloadCall> runningSyncCalls,
List<DownloadCall> finishingCalls); void setDownloadStore(@NonNull DownloadStore store); void enqueue(DownloadTask[] tasks); void enqueue(DownloadTask task); void execute(DownloadTask task); @SuppressWarnings("PMD.ForLoopsMustUseBraces") void cancelAll(); void cancel(IdentifiedTask[] tasks); boolean cancel(IdentifiedTask task); boolean cancel(int id); @Nullable synchronized DownloadTask findSameTask(DownloadTask task); synchronized boolean isRunning(DownloadTask task); synchronized boolean isPending(DownloadTask task); synchronized void flyingCanceled(DownloadCall call); synchronized void finish(DownloadCall call); synchronized boolean isFileConflictAfterRun(@NonNull DownloadTask task); static void setMaxParallelRunningCount(int maxParallelRunningCount); }### Answer:
@Test public void isRunning_async_true() { final DownloadCall mockRunningCall = spy(DownloadCall.create(mockTask(), true, store)); runningAsyncCalls.add(mockRunningCall); when(mockRunningCall.isCanceled()).thenReturn(false); final boolean result = dispatcher.isRunning(mockRunningCall.task); assertThat(result).isEqualTo(true); }
@Test public void isRunning_async_false() { final DownloadCall mockRunningCall = spy(DownloadCall.create(mockTask(1), true, store)); runningAsyncCalls.add(mockRunningCall); when(mockRunningCall.isCanceled()).thenReturn(true); boolean result = dispatcher.isRunning(mockRunningCall.task); assertThat(result).isEqualTo(false); runningAsyncCalls.clear(); when(mockRunningCall.isCanceled()).thenReturn(false); result = dispatcher.isRunning(mockRunningCall.task); assertThat(result).isEqualTo(false); runningAsyncCalls.add(mockRunningCall); result = dispatcher.isRunning(mockTask(2)); assertThat(result).isEqualTo(false); }
@Test public void isRunning_sync_true() { final DownloadCall mockRunningCall = spy(DownloadCall.create(mockTask(), false, store)); runningSyncCalls.add(mockRunningCall); when(mockRunningCall.isCanceled()).thenReturn(false); final boolean result = dispatcher.isRunning(mockRunningCall.task); assertThat(result).isEqualTo(true); }
@Test public void isRunning_sync_false() { final DownloadCall mockRunningCall = spy(DownloadCall.create(mockTask(1), false, store)); runningSyncCalls.add(mockRunningCall); when(mockRunningCall.isCanceled()).thenReturn(true); boolean result = dispatcher.isRunning(mockRunningCall.task); assertThat(result).isEqualTo(false); runningSyncCalls.clear(); when(mockRunningCall.isCanceled()).thenReturn(false); result = dispatcher.isRunning(mockRunningCall.task); assertThat(result).isEqualTo(false); runningSyncCalls.add(mockRunningCall); result = dispatcher.isRunning(mockTask(2)); assertThat(result).isEqualTo(false); } |
### Question:
DownloadDispatcher { public synchronized boolean isPending(DownloadTask task) { Util.d(TAG, "isPending: " + task.getId()); for (DownloadCall call : readyAsyncCalls) { if (call.isCanceled()) continue; if (call.equalsTask(task)) return true; } return false; } DownloadDispatcher(); DownloadDispatcher(List<DownloadCall> readyAsyncCalls,
List<DownloadCall> runningAsyncCalls,
List<DownloadCall> runningSyncCalls,
List<DownloadCall> finishingCalls); void setDownloadStore(@NonNull DownloadStore store); void enqueue(DownloadTask[] tasks); void enqueue(DownloadTask task); void execute(DownloadTask task); @SuppressWarnings("PMD.ForLoopsMustUseBraces") void cancelAll(); void cancel(IdentifiedTask[] tasks); boolean cancel(IdentifiedTask task); boolean cancel(int id); @Nullable synchronized DownloadTask findSameTask(DownloadTask task); synchronized boolean isRunning(DownloadTask task); synchronized boolean isPending(DownloadTask task); synchronized void flyingCanceled(DownloadCall call); synchronized void finish(DownloadCall call); synchronized boolean isFileConflictAfterRun(@NonNull DownloadTask task); static void setMaxParallelRunningCount(int maxParallelRunningCount); }### Answer:
@Test public void isPending_true() { final DownloadCall mockReadyCall = spy(DownloadCall.create(mockTask(1), true, store)); when(mockReadyCall.isCanceled()).thenReturn(false); readyAsyncCalls.add(mockReadyCall); boolean result = dispatcher.isPending(mockReadyCall.task); assertThat(result).isEqualTo(true); }
@Test public void isPending_false() { boolean result = dispatcher.isPending(mockTask(0)); assertThat(result).isEqualTo(false); final DownloadCall pendingCall1 = spy(DownloadCall.create(mockTask(1), true, store)); when(pendingCall1.isCanceled()).thenReturn(false); readyAsyncCalls.add(pendingCall1); result = dispatcher.isPending(mockTask(0)); assertThat(result).isEqualTo(false); when(pendingCall1.isCanceled()).thenReturn(true); result = dispatcher.isPending(pendingCall1.task); assertThat(result).isEqualTo(false); } |
### Question:
IdentifiedTask { public boolean compareIgnoreId(IdentifiedTask another) { if (!getUrl().equals(another.getUrl())) return false; if (getUrl().equals(EMPTY_URL) || getParentFile().equals(EMPTY_FILE)) return false; if (getProvidedPathFile().equals(another.getProvidedPathFile())) return true; if (!getParentFile().equals(another.getParentFile())) return false; final String filename = getFilename(); final String anotherFilename = another.getFilename(); return anotherFilename != null && filename != null && anotherFilename.equals(filename); } abstract int getId(); @NonNull abstract String getUrl(); @NonNull abstract File getParentFile(); @Nullable abstract String getFilename(); boolean compareIgnoreId(IdentifiedTask another); static final String EMPTY_URL; static final File EMPTY_FILE; }### Answer:
@Test public void compareIgnoreId_falseEmpty() { final IdentifiedTask task = DownloadTask.mockTaskForCompare(1); final IdentifiedTask anotherTask = DownloadTask.mockTaskForCompare(2); assertThat(task.compareIgnoreId(task)).isFalse(); assertThat(task.compareIgnoreId(anotherTask)).isFalse(); } |
### Question:
SpeedCalculator { public String instantSpeed() { return getSpeedWithSIAndFlush(); } synchronized void reset(); synchronized void downloading(long increaseBytes); synchronized void flush(); long getInstantBytesPerSecondAndFlush(); synchronized long getBytesPerSecondAndFlush(); synchronized long getBytesPerSecondFromBegin(); synchronized void endTask(); String instantSpeed(); String speed(); String lastSpeed(); synchronized long getInstantSpeedDurationMillis(); String getSpeedWithBinaryAndFlush(); String getSpeedWithSIAndFlush(); String averageSpeed(); String speedFromBegin(); }### Answer:
@Test public void instantSpeed() { doReturn("1").when(calculator).getSpeedWithSIAndFlush(); assertThat(calculator.instantSpeed()).isEqualTo("1"); } |
### Question:
ProcessFileStrategy { public void discardProcess(@NonNull DownloadTask task) throws IOException { final File file = task.getFile(); if (file == null) return; if (file.exists() && !file.delete()) { throw new IOException("Delete file failed!"); } } @NonNull MultiPointOutputStream createProcessStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); void completeProcessStream(@NonNull MultiPointOutputStream processOutputStream,
@NonNull DownloadTask task); void discardProcess(@NonNull DownloadTask task); @NonNull FileLock getFileLock(); boolean isPreAllocateLength(@NonNull DownloadTask task); }### Answer:
@Test public void discardProcess() throws IOException { final File existFile = new File("./exist-path"); existFile.createNewFile(); when(task.getFile()).thenReturn(existFile); strategy.discardProcess(task); assertThat(existFile.exists()).isFalse(); }
@Test(expected = IOException.class) public void discardProcess_deleteFailed() throws IOException { final File file = mock(File.class); when(task.getFile()).thenReturn(file); when(file.exists()).thenReturn(true); when(file.delete()).thenReturn(false); strategy.discardProcess(task); } |
### Question:
ProcessFileStrategy { public boolean isPreAllocateLength(@NonNull DownloadTask task) { boolean supportSeek = OkDownload.with().outputStreamFactory().supportSeek(); if (!supportSeek) return false; if (task.getSetPreAllocateLength() != null) return task.getSetPreAllocateLength(); return true; } @NonNull MultiPointOutputStream createProcessStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); void completeProcessStream(@NonNull MultiPointOutputStream processOutputStream,
@NonNull DownloadTask task); void discardProcess(@NonNull DownloadTask task); @NonNull FileLock getFileLock(); boolean isPreAllocateLength(@NonNull DownloadTask task); }### Answer:
@Test public void isPreAllocateLength() throws IOException { mockOkDownload(); when(task.getSetPreAllocateLength()).thenReturn(null); final DownloadOutputStream.Factory factory = OkDownload.with().outputStreamFactory(); when(factory.supportSeek()).thenReturn(false); assertThat(strategy.isPreAllocateLength(task)).isFalse(); when(factory.supportSeek()).thenReturn(true); assertThat(strategy.isPreAllocateLength(task)).isTrue(); when(task.getSetPreAllocateLength()).thenReturn(false); assertThat(strategy.isPreAllocateLength(task)).isFalse(); when(task.getSetPreAllocateLength()).thenReturn(true); assertThat(strategy.isPreAllocateLength(task)).isTrue(); when(factory.supportSeek()).thenReturn(false); assertThat(strategy.isPreAllocateLength(task)).isFalse(); } |
### Question:
MultiPointOutputStream { public synchronized void write(int blockIndex, byte[] bytes, int length) throws IOException { if (canceled) return; outputStream(blockIndex).write(bytes, 0, length); allNoSyncLength.addAndGet(length); noSyncLengthMap.get(blockIndex).addAndGet(length); inspectAndPersist(); } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void write() throws IOException { doReturn(stream0).when(multiPointOutputStream).outputStream(anyInt()); doNothing().when(multiPointOutputStream).inspectAndPersist(); multiPointOutputStream.noSyncLengthMap.put(1, new AtomicLong()); multiPointOutputStream.noSyncLengthMap.put(2, new AtomicLong()); multiPointOutputStream.write(2, bytes, 16); verify(stream0).write(eq(bytes), eq(0), eq(16)); assertThat(multiPointOutputStream.allNoSyncLength.get()).isEqualTo(16); assertThat(multiPointOutputStream.noSyncLengthMap.get(1).get()).isEqualTo(0); assertThat(multiPointOutputStream.noSyncLengthMap.get(2).get()).isEqualTo(16); verify(multiPointOutputStream).inspectAndPersist(); } |
### Question:
MultiPointOutputStream { public synchronized void cancel() { if (requireStreamBlocks == null) return; if (canceled) return; canceled = true; noMoreStreamList.addAll(requireStreamBlocks); try { if (allNoSyncLength.get() <= 0) return; if (syncFuture != null && !syncFuture.isDone()) { inspectValidPath(); OkDownload.with().processFileStrategy().getFileLock().increaseLock(path); try { ensureSync(true, -1); } finally { OkDownload.with().processFileStrategy().getFileLock().decreaseLock(path); } } } finally { for (Integer blockIndex : requireStreamBlocks) { try { close(blockIndex); } catch (IOException e) { Util.d(TAG, "OutputStream close failed task[" + task.getId() + "] block[" + blockIndex + "]" + e); } } store.onTaskEnd(task.getId(), EndCause.CANCELED, null); } } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void cancel() throws IOException { multiPointOutputStream.requireStreamBlocks = new ArrayList<Integer>() {{ add(0); add(1); }}; multiPointOutputStream.noSyncLengthMap.put(0, new AtomicLong()); multiPointOutputStream.noSyncLengthMap.put(1, new AtomicLong()); multiPointOutputStream.allNoSyncLength.set(1); final ProcessFileStrategy strategy = OkDownload.with().processFileStrategy(); final FileLock fileLock = mock(FileLock.class); when(strategy.getFileLock()).thenReturn(fileLock); doNothing().when(multiPointOutputStream).close(anyInt()); doNothing().when(multiPointOutputStream).ensureSync(true, -1); multiPointOutputStream.cancel(); assertThat(multiPointOutputStream.noMoreStreamList).containsExactly(0, 1); verify(multiPointOutputStream).ensureSync(eq(true), eq(-1)); verify(multiPointOutputStream).close(eq(0)); verify(multiPointOutputStream).close(eq(1)); verify(fileLock).increaseLock(eq(existFile.getAbsolutePath())); verify(fileLock).decreaseLock(eq(existFile.getAbsolutePath())); verify(store).onTaskEnd(eq(task.getId()), eq(EndCause.CANCELED), nullable(Exception.class)); } |
### Question:
MultiPointOutputStream { public void done(int blockIndex) throws IOException { noMoreStreamList.add(blockIndex); try { if (syncException != null) throw syncException; if (syncFuture != null && !syncFuture.isDone()) { final AtomicLong noSyncLength = noSyncLengthMap.get(blockIndex); if (noSyncLength != null && noSyncLength.get() > 0) { inspectStreamState(doneState); final boolean isNoMoreStream = doneState.isNoMoreStream; ensureSync(isNoMoreStream, blockIndex); } } else { if (syncFuture == null) { Util.d(TAG, "OutputStream done but no need to ensure sync, because the " + "sync job not run yet. task[" + task.getId() + "] block[" + blockIndex + "]"); } else { Util.d(TAG, "OutputStream done but no need to ensure sync, because the " + "syncFuture.isDone[" + syncFuture.isDone() + "] task[" + task.getId() + "] block[" + blockIndex + "]"); } } } finally { close(blockIndex); } } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test(expected = IOException.class) public void done_syncException() throws IOException { multiPointOutputStream.syncException = new IOException(); multiPointOutputStream.done(1); } |
### Question:
MultiPointOutputStream { void runSyncDelayException() { try { runSync(); } catch (IOException e) { syncException = e; Util.w(TAG, "Sync to breakpoint-store for task[" + task.getId() + "] " + "failed with cause: " + e); } } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void runSyncDelayException() throws IOException { final IOException exception = mock(IOException.class); doThrow(exception).when(multiPointOutputStream).runSync(); multiPointOutputStream.runSyncDelayException(); assertThat(multiPointOutputStream.syncException).isEqualTo(exception); } |
### Question:
MultiPointOutputStream { void runSync() throws IOException { Util.d(TAG, "OutputStream start flush looper task[" + task.getId() + "] with " + "syncBufferIntervalMills[" + syncBufferIntervalMills + "] " + "syncBufferSize[" + syncBufferSize + "]"); runSyncThread = Thread.currentThread(); long nextParkMills = syncBufferIntervalMills; flushProcess(); while (true) { parkThread(nextParkMills); inspectStreamState(state); if (state.isStreamsEndOrChanged()) { Util.d(TAG, "runSync state change isNoMoreStream[" + state.isNoMoreStream + "]" + " newNoMoreStreamBlockList[" + state.newNoMoreStreamBlockList + "]"); if (allNoSyncLength.get() > 0) { flushProcess(); } for (Integer blockIndex : state.newNoMoreStreamBlockList) { final Thread parkedThread = parkedRunBlockThreadMap.get(blockIndex); parkedRunBlockThreadMap.remove(blockIndex); if (parkedThread != null) unparkThread(parkedThread); } if (state.isNoMoreStream) { final int size = parkedRunBlockThreadMap.size(); for (int i = 0; i < size; i++) { final Thread parkedThread = parkedRunBlockThreadMap.valueAt(i); if (parkedThread != null) unparkThread(parkedThread); } parkedRunBlockThreadMap.clear(); break; } else { continue; } } if (isNoNeedFlushForLength()) { nextParkMills = syncBufferIntervalMills; continue; } nextParkMills = getNextParkMillisecond(); if (nextParkMills > 0) { continue; } flushProcess(); nextParkMills = syncBufferIntervalMills; } Util.d(TAG, "OutputStream stop flush looper task[" + task.getId() + "]"); } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void runSync() throws IOException { final MultiPointOutputStream.StreamsState state = spy(new MultiPointOutputStream.StreamsState()); multiPointOutputStream.state = state; when(state.isStreamsEndOrChanged()).thenReturn(false, false, false, true); doNothing().when(multiPointOutputStream).parkThread(anyLong()); doNothing().when(multiPointOutputStream).unparkThread(any(Thread.class)); doNothing().when(multiPointOutputStream).flushProcess(); doNothing().when(multiPointOutputStream).inspectStreamState(state); final Thread thread0 = mock(Thread.class); final Thread thread1 = mock(Thread.class); multiPointOutputStream.parkedRunBlockThreadMap.put(0, thread0); multiPointOutputStream.parkedRunBlockThreadMap.put(1, thread1); multiPointOutputStream.allNoSyncLength.set(1); state.newNoMoreStreamBlockList.add(0); state.newNoMoreStreamBlockList.add(1); state.isNoMoreStream = true; when(multiPointOutputStream.isNoNeedFlushForLength()).thenReturn(true, false); when(multiPointOutputStream.getNextParkMillisecond()).thenReturn(1L, -1L); multiPointOutputStream.runSync(); verify(multiPointOutputStream, times(3)).flushProcess(); assertThat(multiPointOutputStream.parkedRunBlockThreadMap.size()).isZero(); verify(multiPointOutputStream).unparkThread(eq(thread0)); verify(multiPointOutputStream).unparkThread(eq(thread1)); } |
### Question:
MultiPointOutputStream { boolean isNoNeedFlushForLength() { return allNoSyncLength.get() < syncBufferSize; } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void isNoNeedFlushForLength() { multiPointOutputStream.allNoSyncLength.set(0); assertThat(multiPointOutputStream.isNoNeedFlushForLength()).isFalse(); multiPointOutputStream.allNoSyncLength.set(-1); assertThat(multiPointOutputStream.isNoNeedFlushForLength()).isTrue(); } |
### Question:
MultiPointOutputStream { long getNextParkMillisecond() { long farToLastSyncMills = now() - lastSyncTimestamp.get(); return syncBufferIntervalMills - farToLastSyncMills; } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void getNextParkMillisecond() { when(multiPointOutputStream.now()).thenReturn(2L); multiPointOutputStream.lastSyncTimestamp.set(1L); assertThat(multiPointOutputStream.getNextParkMillisecond()).isEqualTo(-1L); } |
### Question:
SpeedCalculator { public String lastSpeed() { return humanReadableSpeed(bytesPerSecond, true); } synchronized void reset(); synchronized void downloading(long increaseBytes); synchronized void flush(); long getInstantBytesPerSecondAndFlush(); synchronized long getBytesPerSecondAndFlush(); synchronized long getBytesPerSecondFromBegin(); synchronized void endTask(); String instantSpeed(); String speed(); String lastSpeed(); synchronized long getInstantSpeedDurationMillis(); String getSpeedWithBinaryAndFlush(); String getSpeedWithSIAndFlush(); String averageSpeed(); String speedFromBegin(); }### Answer:
@Test public void lastSpeed() { calculator.bytesPerSecond = 1; assertThat(calculator.lastSpeed()).isEqualTo("1 B/s"); } |
### Question:
MultiPointOutputStream { void flushProcess() throws IOException { boolean success; final int size; synchronized (noSyncLengthMap) { size = noSyncLengthMap.size(); } final SparseArray<Long> increaseLengthMap = new SparseArray<>(size); try { for (int i = 0; i < size; i++) { final int blockIndex = outputStreamMap.keyAt(i); final long noSyncLength = noSyncLengthMap.get(blockIndex).get(); if (noSyncLength > 0) { increaseLengthMap.put(blockIndex, noSyncLength); final DownloadOutputStream outputStream = outputStreamMap .get(blockIndex); outputStream.flushAndSync(); } } success = true; } catch (IOException ex) { Util.w(TAG, "OutputStream flush and sync data to filesystem failed " + ex); success = false; } if (success) { final int increaseLengthSize = increaseLengthMap.size(); long allIncreaseLength = 0; for (int i = 0; i < increaseLengthSize; i++) { final int blockIndex = increaseLengthMap.keyAt(i); final long noSyncLength = increaseLengthMap.valueAt(i); store.onSyncToFilesystemSuccess(info, blockIndex, noSyncLength); allIncreaseLength += noSyncLength; noSyncLengthMap.get(blockIndex).addAndGet(-noSyncLength); Util.d(TAG, "OutputStream sync success (" + task.getId() + ") " + "block(" + blockIndex + ") " + " syncLength(" + noSyncLength + ")" + " currentOffset(" + info.getBlock(blockIndex).getCurrentOffset() + ")"); } allNoSyncLength.addAndGet(-allIncreaseLength); lastSyncTimestamp.set(SystemClock.uptimeMillis()); } } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void flushProcess() throws IOException { final DownloadOutputStream outputStream = mock(DownloadOutputStream.class); doReturn(outputStream).when(multiPointOutputStream).outputStream(1); when(info.getBlock(1)).thenReturn(mock(BlockInfo.class)); multiPointOutputStream.allNoSyncLength.addAndGet(10); multiPointOutputStream.noSyncLengthMap.put(1, new AtomicLong(10)); multiPointOutputStream.outputStreamMap.put(1, mock(DownloadOutputStream.class)); multiPointOutputStream.flushProcess(); verify(store).onSyncToFilesystemSuccess(info, 1, 10); assertThat(multiPointOutputStream.allNoSyncLength.get()).isZero(); assertThat(multiPointOutputStream.noSyncLengthMap.get(1).get()).isZero(); } |
### Question:
MultiPointOutputStream { void inspectAndPersist() throws IOException { if (syncException != null) throw syncException; if (syncFuture == null) { synchronized (syncRunnable) { if (syncFuture == null) { syncFuture = executeSyncRunnableAsync(); } } } } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void inspectAndPersist() throws IOException { final Future newFuture = mock(Future.class); doReturn(newFuture).when(multiPointOutputStream).executeSyncRunnableAsync(); multiPointOutputStream.syncFuture = syncFuture; multiPointOutputStream.inspectAndPersist(); assertThat(multiPointOutputStream.syncFuture).isEqualTo(syncFuture); multiPointOutputStream.syncFuture = null; multiPointOutputStream.inspectAndPersist(); assertThat(multiPointOutputStream.syncFuture).isEqualTo(newFuture); }
@Test(expected = IOException.class) public void inspectAndPersist_syncException() throws IOException { multiPointOutputStream.syncException = new IOException(); multiPointOutputStream.inspectAndPersist(); }
@Test(expected = IOException.class) public void inspectComplete_syncException() throws IOException { multiPointOutputStream.syncException = new IOException(); multiPointOutputStream.inspectAndPersist(); } |
### Question:
MultiPointOutputStream { public void inspectComplete(int blockIndex) throws IOException { final BlockInfo blockInfo = info.getBlock(blockIndex); if (!Util.isCorrectFull(blockInfo.getCurrentOffset(), blockInfo.getContentLength())) { throw new IOException("The current offset on block-info isn't update correct, " + blockInfo.getCurrentOffset() + " != " + blockInfo.getContentLength() + " on " + blockIndex); } } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test(expected = IOException.class) public void inspectComplete_notFull() throws IOException { final BlockInfo blockInfo = mock(BlockInfo.class); when(info.getBlock(1)).thenReturn(blockInfo); when(blockInfo.getContentLength()).thenReturn(9L); when(blockInfo.getCurrentOffset()).thenReturn(10L); multiPointOutputStream.inspectComplete(1); } |
### Question:
MultiPointOutputStream { synchronized void close(int blockIndex) throws IOException { final DownloadOutputStream outputStream = outputStreamMap.get(blockIndex); if (outputStream != null) { outputStream.close(); outputStreamMap.remove(blockIndex); Util.d(TAG, "OutputStream close task[" + task.getId() + "] block[" + blockIndex + "]"); } } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void close_noExist() throws IOException { final DownloadOutputStream stream0 = mock(DownloadOutputStream.class); final DownloadOutputStream stream1 = mock(DownloadOutputStream.class); multiPointOutputStream.outputStreamMap.put(0, stream0); multiPointOutputStream.outputStreamMap.put(1, stream1); multiPointOutputStream.close(2); verify(stream0, never()).close(); verify(stream1, never()).close(); assertThat(multiPointOutputStream.outputStreamMap.size()).isEqualTo(2); }
@Test public void close() throws IOException { final DownloadOutputStream stream0 = mock(DownloadOutputStream.class); final DownloadOutputStream stream1 = mock(DownloadOutputStream.class); multiPointOutputStream.outputStreamMap.put(0, stream0); multiPointOutputStream.outputStreamMap.put(1, stream1); multiPointOutputStream.close(1); verify(stream0, never()).close(); verify(stream1).close(); assertThat(multiPointOutputStream.outputStreamMap.size()).isEqualTo(1); assertThat(multiPointOutputStream.outputStreamMap.get(0)).isEqualTo(stream0); } |
### Question:
MultiPointOutputStream { void inspectStreamState(StreamsState state) { state.newNoMoreStreamBlockList.clear(); @SuppressWarnings("unchecked") final List<Integer> clonedList = (List<Integer>) noMoreStreamList.clone(); final Set<Integer> uniqueBlockList = new HashSet<>(clonedList); final int noMoreStreamBlockCount = uniqueBlockList.size(); if (noMoreStreamBlockCount != requireStreamBlocks.size()) { Util.d(TAG, "task[" + task.getId() + "] current need fetching block count " + requireStreamBlocks.size() + " is not equal to no more stream block count " + noMoreStreamBlockCount); state.isNoMoreStream = false; } else { Util.d(TAG, "task[" + task.getId() + "] current need fetching block count " + requireStreamBlocks.size() + " is equal to no more stream block count " + noMoreStreamBlockCount); state.isNoMoreStream = true; } final SparseArray<DownloadOutputStream> streamMap = outputStreamMap.clone(); final int size = streamMap.size(); for (int i = 0; i < size; i++) { final int blockIndex = streamMap.keyAt(i); if (noMoreStreamList.contains(blockIndex) && !state.noMoreStreamBlockList.contains(blockIndex)) { state.noMoreStreamBlockList.add(blockIndex); state.newNoMoreStreamBlockList.add(blockIndex); } } } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void inspectStreamState() { final MultiPointOutputStream.StreamsState state = new MultiPointOutputStream.StreamsState(); multiPointOutputStream.outputStreamMap.put(0, stream0); multiPointOutputStream.outputStreamMap.put(0, stream0); multiPointOutputStream.outputStreamMap.put(1, stream0); multiPointOutputStream.outputStreamMap.put(1, stream0); multiPointOutputStream.requireStreamBlocks = new ArrayList<Integer>() {{ add(0); add(1); }}; multiPointOutputStream.inspectStreamState(state); assertThat(state.isNoMoreStream).isFalse(); assertThat(state.noMoreStreamBlockList).isEmpty(); assertThat(state.newNoMoreStreamBlockList).isEmpty(); multiPointOutputStream.noMoreStreamList.add(1); multiPointOutputStream.inspectStreamState(state); assertThat(state.isNoMoreStream).isFalse(); assertThat(state.noMoreStreamBlockList).containsExactly(1); assertThat(state.newNoMoreStreamBlockList).containsExactly(1); multiPointOutputStream.noMoreStreamList.add(0); multiPointOutputStream.inspectStreamState(state); assertThat(state.isNoMoreStream).isTrue(); assertThat(state.noMoreStreamBlockList).containsExactly(1, 0); assertThat(state.newNoMoreStreamBlockList).containsExactly(0); multiPointOutputStream.inspectStreamState(state); assertThat(state.isNoMoreStream).isTrue(); assertThat(state.noMoreStreamBlockList).containsExactly(1, 0); assertThat(state.newNoMoreStreamBlockList).isEmpty(); } |
### Question:
MultiPointOutputStream { public void setRequireStreamBlocks(List<Integer> requireStreamBlocks) { this.requireStreamBlocks = requireStreamBlocks; } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void setRequireStreamBlocks() { assertThat(multiPointOutputStream.requireStreamBlocks).isEqualTo(null); final List<Integer> requireStreamBlocks = new ArrayList<Integer>() {{ add(0); add(1); add(2); }}; multiPointOutputStream.setRequireStreamBlocks(requireStreamBlocks); assertThat(multiPointOutputStream.requireStreamBlocks).isEqualTo(requireStreamBlocks); } |
### Question:
SpeedCalculator { public synchronized long getInstantSpeedDurationMillis() { return nowMillis() - timestamp; } synchronized void reset(); synchronized void downloading(long increaseBytes); synchronized void flush(); long getInstantBytesPerSecondAndFlush(); synchronized long getBytesPerSecondAndFlush(); synchronized long getBytesPerSecondFromBegin(); synchronized void endTask(); String instantSpeed(); String speed(); String lastSpeed(); synchronized long getInstantSpeedDurationMillis(); String getSpeedWithBinaryAndFlush(); String getSpeedWithSIAndFlush(); String averageSpeed(); String speedFromBegin(); }### Answer:
@Test public void getInstantSpeedDurationMillis() { doReturn(2L).when(calculator).nowMillis(); calculator.timestamp = 1; assertThat(calculator.getInstantSpeedDurationMillis()).isOne(); } |
### Question:
MultiPointOutputStream { void inspectFreeSpace(StatFs statFs, long requireSpace) throws PreAllocateException { final long freeSpace = Util.getFreeSpaceBytes(statFs); if (freeSpace < requireSpace) { throw new PreAllocateException(requireSpace, freeSpace); } } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void inspectFreeSpace_freeSpaceNotEnough() throws PreAllocateException { final StatFs statFs = mock(StatFs.class); when(statFs.getAvailableBlocks()).thenReturn(1); when(statFs.getBlockSize()).thenReturn(2); thrown.expectMessage("There is Free space less than Require space: 2 < 3"); thrown.expect(PreAllocateException.class); multiPointOutputStream.inspectFreeSpace(statFs, 3); }
@Test public void inspectFreeSpace() throws PreAllocateException { final StatFs statFs = mock(StatFs.class); when(statFs.getAvailableBlocks()).thenReturn(1); when(statFs.getBlockSize()).thenReturn(2); multiPointOutputStream.inspectFreeSpace(statFs, 2); } |
### Question:
MultiPointOutputStream { public void catchBlockConnectException(int blockIndex) { noMoreStreamList.add(blockIndex); } MultiPointOutputStream(@NonNull final DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store,
@Nullable Runnable syncRunnable); MultiPointOutputStream(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull DownloadStore store); synchronized void write(int blockIndex, byte[] bytes, int length); void cancelAsync(); synchronized void cancel(); void done(int blockIndex); void inspectComplete(int blockIndex); void setRequireStreamBlocks(List<Integer> requireStreamBlocks); void catchBlockConnectException(int blockIndex); }### Answer:
@Test public void catchBlockConnectException() { multiPointOutputStream.catchBlockConnectException(2); assertThat(multiPointOutputStream.noMoreStreamList).hasSize(1); assertThat(multiPointOutputStream.noMoreStreamList).containsExactly(2); } |
### Question:
FileLock { public void increaseLock(@NonNull String path) { AtomicInteger lockCount; synchronized (fileLockCountMap) { lockCount = fileLockCountMap.get(path); } if (lockCount == null) { lockCount = new AtomicInteger(0); synchronized (fileLockCountMap) { fileLockCountMap.put(path, lockCount); } } Util.d(TAG, "increaseLock increase lock-count to " + lockCount.incrementAndGet() + path); } FileLock(@NonNull Map<String, AtomicInteger> fileLockCountMap,
@NonNull Map<String, Thread> waitThreadForFileLockMap); FileLock(); void increaseLock(@NonNull String path); void decreaseLock(@NonNull String path); void waitForRelease(@NonNull String filePath); }### Answer:
@Test public void increaseLock() { fileLock.increaseLock(filePath1); assertThat(fileLockCountMap.get(filePath1).get()).isOne(); fileLock.increaseLock(filePath1); assertThat(fileLockCountMap.get(filePath1).get()).isEqualTo(2); fileLock.increaseLock(filePath2); assertThat(fileLockCountMap.get(filePath2).get()).isOne(); fileLock.increaseLock(filePath2); assertThat(fileLockCountMap.get(filePath2).get()).isEqualTo(2); } |
### Question:
FileLock { public void decreaseLock(@NonNull String path) { AtomicInteger lockCount; synchronized (fileLockCountMap) { lockCount = fileLockCountMap.get(path); } if (lockCount != null && lockCount.decrementAndGet() == 0) { Util.d(TAG, "decreaseLock decrease lock-count to 0 " + path); final Thread lockedThread; synchronized (waitThreadForFileLockMap) { lockedThread = waitThreadForFileLockMap.get(path); if (lockedThread != null) { waitThreadForFileLockMap.remove(path); } } if (lockedThread != null) { Util.d(TAG, "decreaseLock " + path + " unpark locked thread " + lockCount); unpark(lockedThread); } synchronized (fileLockCountMap) { fileLockCountMap.remove(path); } } } FileLock(@NonNull Map<String, AtomicInteger> fileLockCountMap,
@NonNull Map<String, Thread> waitThreadForFileLockMap); FileLock(); void increaseLock(@NonNull String path); void decreaseLock(@NonNull String path); void waitForRelease(@NonNull String filePath); }### Answer:
@Test public void decreaseLock() { waitThreadForFileLockMap.put(filePath1, lockedThread); fileLock.decreaseLock(filePath1); assertThat(fileLockCountMap.get(filePath1)).isNull(); fileLockCountMap.put(filePath1, new AtomicInteger(2)); fileLock.decreaseLock(filePath1); assertThat(fileLockCountMap.get(filePath1).get()).isOne(); fileLock.decreaseLock(filePath1); assertThat(fileLockCountMap.get(filePath1)).isNull(); verify(fileLock).unpark(eq(lockedThread)); assertThat(waitThreadForFileLockMap.isEmpty()).isTrue(); fileLock.decreaseLock(filePath2); assertThat(fileLockCountMap.get(filePath2)).isNull(); } |
### Question:
FileLock { public void waitForRelease(@NonNull String filePath) { AtomicInteger lockCount; synchronized (fileLockCountMap) { lockCount = fileLockCountMap.get(filePath); } if (lockCount == null || lockCount.get() <= 0) return; synchronized (waitThreadForFileLockMap) { waitThreadForFileLockMap.put(filePath, Thread.currentThread()); } Util.d(TAG, "waitForRelease start " + filePath); while (true) { if (isNotLocked(lockCount)) break; park(); } Util.d(TAG, "waitForRelease finish " + filePath); } FileLock(@NonNull Map<String, AtomicInteger> fileLockCountMap,
@NonNull Map<String, Thread> waitThreadForFileLockMap); FileLock(); void increaseLock(@NonNull String path); void decreaseLock(@NonNull String path); void waitForRelease(@NonNull String filePath); }### Answer:
@Test public void waitForRelease() { fileLock.waitForRelease(filePath1); verify(fileLock, never()).park(); assertThat(waitThreadForFileLockMap.isEmpty()).isTrue(); fileLockCountMap.put(filePath1, new AtomicInteger(1)); doReturn(false, true).when(fileLock).isNotLocked(any(AtomicInteger.class)); fileLock.waitForRelease(filePath1); assertThat(waitThreadForFileLockMap.get(filePath1)).isEqualTo(Thread.currentThread()); verify(fileLock).park(); } |
### Question:
DownloadUriOutputStream implements DownloadOutputStream { @Override public void write(byte[] b, int off, int len) throws IOException { out.write(b, off, len); } DownloadUriOutputStream(Context context, Uri uri, int bufferSize); DownloadUriOutputStream(@NonNull FileChannel channel, @NonNull ParcelFileDescriptor pdf,
@NonNull FileOutputStream fos,
@NonNull BufferedOutputStream out); @Override void write(byte[] b, int off, int len); @Override void close(); @Override void flushAndSync(); @Override void seek(long offset); @Override void setLength(long newLength); }### Answer:
@Test public void write() throws Exception { byte[] bytes = new byte[2]; outputStream.write(bytes, 0, 1); verify(out).write(eq(bytes), eq(0), eq(1)); } |
### Question:
SpeedCalculator { public String getSpeedWithBinaryAndFlush() { return humanReadableSpeed(getInstantBytesPerSecondAndFlush(), false); } synchronized void reset(); synchronized void downloading(long increaseBytes); synchronized void flush(); long getInstantBytesPerSecondAndFlush(); synchronized long getBytesPerSecondAndFlush(); synchronized long getBytesPerSecondFromBegin(); synchronized void endTask(); String instantSpeed(); String speed(); String lastSpeed(); synchronized long getInstantSpeedDurationMillis(); String getSpeedWithBinaryAndFlush(); String getSpeedWithSIAndFlush(); String averageSpeed(); String speedFromBegin(); }### Answer:
@Test public void getSpeedWithBinaryAndFlush() { doReturn(1054L).when(calculator).getInstantBytesPerSecondAndFlush(); assertThat(calculator.getSpeedWithBinaryAndFlush()).isEqualTo("1.0 KiB/s"); } |
### Question:
DownloadUriOutputStream implements DownloadOutputStream { @Override public void close() throws IOException { out.close(); fos.close(); pdf.close(); } DownloadUriOutputStream(Context context, Uri uri, int bufferSize); DownloadUriOutputStream(@NonNull FileChannel channel, @NonNull ParcelFileDescriptor pdf,
@NonNull FileOutputStream fos,
@NonNull BufferedOutputStream out); @Override void write(byte[] b, int off, int len); @Override void close(); @Override void flushAndSync(); @Override void seek(long offset); @Override void setLength(long newLength); }### Answer:
@Test public void close() throws Exception { outputStream.close(); verify(out).close(); verify(fos).close(); } |
### Question:
DownloadUriOutputStream implements DownloadOutputStream { @Override public void flushAndSync() throws IOException { out.flush(); pdf.getFileDescriptor().sync(); } DownloadUriOutputStream(Context context, Uri uri, int bufferSize); DownloadUriOutputStream(@NonNull FileChannel channel, @NonNull ParcelFileDescriptor pdf,
@NonNull FileOutputStream fos,
@NonNull BufferedOutputStream out); @Override void write(byte[] b, int off, int len); @Override void close(); @Override void flushAndSync(); @Override void seek(long offset); @Override void setLength(long newLength); }### Answer:
@Test public void flushAndSync() throws Exception { when(pdf.getFileDescriptor()).thenReturn(fd); thrown.expect(SyncFailedException.class); thrown.expectMessage("sync failed"); outputStream.flushAndSync(); verify(out).flush(); } |
### Question:
DownloadUriOutputStream implements DownloadOutputStream { @Override public void seek(long offset) throws IOException { channel.position(offset); } DownloadUriOutputStream(Context context, Uri uri, int bufferSize); DownloadUriOutputStream(@NonNull FileChannel channel, @NonNull ParcelFileDescriptor pdf,
@NonNull FileOutputStream fos,
@NonNull BufferedOutputStream out); @Override void write(byte[] b, int off, int len); @Override void close(); @Override void flushAndSync(); @Override void seek(long offset); @Override void setLength(long newLength); }### Answer:
@Test public void seek() throws Exception { outputStream.seek(1); verify(channel).position(eq(1L)); } |
### Question:
DownloadUriOutputStream implements DownloadOutputStream { @Override public void setLength(long newLength) { final String tag = "DownloadUriOutputStream"; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { try { Os.posix_fallocate(pdf.getFileDescriptor(), 0, newLength); } catch (Throwable e) { if (e instanceof ErrnoException) { if (((ErrnoException) e).errno == OsConstants.ENOSYS || ((ErrnoException) e).errno == OsConstants.ENOTSUP) { Util.w(tag, "fallocate() not supported; falling back to ftruncate()"); try { Os.ftruncate(pdf.getFileDescriptor(), newLength); } catch (Throwable e1) { Util.w(tag, "It can't pre-allocate length(" + newLength + ") on the sdk" + " version(" + Build.VERSION.SDK_INT + "), because of " + e1); } } } else { Util.w(tag, "It can't pre-allocate length(" + newLength + ") on the sdk" + " version(" + Build.VERSION.SDK_INT + "), because of " + e); } } } else { Util.w(tag, "It can't pre-allocate length(" + newLength + ") on the sdk " + "version(" + Build.VERSION.SDK_INT + ")"); } } DownloadUriOutputStream(Context context, Uri uri, int bufferSize); DownloadUriOutputStream(@NonNull FileChannel channel, @NonNull ParcelFileDescriptor pdf,
@NonNull FileOutputStream fos,
@NonNull BufferedOutputStream out); @Override void write(byte[] b, int off, int len); @Override void close(); @Override void flushAndSync(); @Override void seek(long offset); @Override void setLength(long newLength); }### Answer:
@Test public void setLength() { outputStream.setLength(1); verify(pdf).getFileDescriptor(); } |
### Question:
DownloadListener4 implements DownloadListener,
Listener4Assist.Listener4Callback, ListenerAssist { public void setAssistExtend(@NonNull Listener4Assist.AssistExtend assistExtend) { this.assist.setAssistExtend(assistExtend); } DownloadListener4(Listener4Assist assist); DownloadListener4(); void setAssistExtend(@NonNull Listener4Assist.AssistExtend assistExtend); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override final void downloadFromBeginning(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override final void downloadFromBreakpoint(@NonNull DownloadTask task,
@NonNull BreakpointInfo info); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void fetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void setAssistExtend() { listener4.setAssistExtend(assistExtend); verify(assist).setAssistExtend(assistExtend); } |
### Question:
DownloadListener4 implements DownloadListener,
Listener4Assist.Listener4Callback, ListenerAssist { @Override public final void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info, @NonNull ResumeFailedCause cause) { assist.infoReady(task, info, false); } DownloadListener4(Listener4Assist assist); DownloadListener4(); void setAssistExtend(@NonNull Listener4Assist.AssistExtend assistExtend); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override final void downloadFromBeginning(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override final void downloadFromBreakpoint(@NonNull DownloadTask task,
@NonNull BreakpointInfo info); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void fetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void downloadFromBeginning() { listener4.downloadFromBeginning(task, info, resumeFailedCause); verify(assist).infoReady(eq(task), eq(info), eq(false)); } |
### Question:
DownloadListener4 implements DownloadListener,
Listener4Assist.Listener4Callback, ListenerAssist { @Override public final void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info) { assist.infoReady(task, info, true); } DownloadListener4(Listener4Assist assist); DownloadListener4(); void setAssistExtend(@NonNull Listener4Assist.AssistExtend assistExtend); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override final void downloadFromBeginning(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override final void downloadFromBreakpoint(@NonNull DownloadTask task,
@NonNull BreakpointInfo info); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void fetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void downloadFromBreakpoint() { listener4.downloadFromBreakpoint(task, info); verify(assist).infoReady(eq(task), eq(info), eq(true)); } |
### Question:
DownloadListener4 implements DownloadListener,
Listener4Assist.Listener4Callback, ListenerAssist { @Override public final void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes) { assist.fetchProgress(task, blockIndex, increaseBytes); } DownloadListener4(Listener4Assist assist); DownloadListener4(); void setAssistExtend(@NonNull Listener4Assist.AssistExtend assistExtend); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override final void downloadFromBeginning(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override final void downloadFromBreakpoint(@NonNull DownloadTask task,
@NonNull BreakpointInfo info); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void fetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void fetchProgress() { listener4.fetchProgress(task, 1, 2); verify(assist).fetchProgress(eq(task), eq(1), eq(2L)); } |
### Question:
DownloadListener4 implements DownloadListener,
Listener4Assist.Listener4Callback, ListenerAssist { @Override public void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength) { assist.fetchEnd(task, blockIndex); } DownloadListener4(Listener4Assist assist); DownloadListener4(); void setAssistExtend(@NonNull Listener4Assist.AssistExtend assistExtend); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override final void downloadFromBeginning(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override final void downloadFromBreakpoint(@NonNull DownloadTask task,
@NonNull BreakpointInfo info); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void fetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void fetchEnd() { listener4.fetchEnd(task, 1, 2); verify(assist).fetchEnd(eq(task), eq(1)); } |
### Question:
DownloadListener4 implements DownloadListener,
Listener4Assist.Listener4Callback, ListenerAssist { @Override public final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause, @Nullable Exception realCause) { assist.taskEnd(task, cause, realCause); } DownloadListener4(Listener4Assist assist); DownloadListener4(); void setAssistExtend(@NonNull Listener4Assist.AssistExtend assistExtend); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override final void downloadFromBeginning(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override final void downloadFromBreakpoint(@NonNull DownloadTask task,
@NonNull BreakpointInfo info); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void fetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void taskEnd() { listener4.taskEnd(task, endCause, exception); verify(assist).taskEnd(eq(task), eq(endCause), eq(exception)); } |
### Question:
SpeedCalculator { public String getSpeedWithSIAndFlush() { return humanReadableSpeed(getInstantBytesPerSecondAndFlush(), true); } synchronized void reset(); synchronized void downloading(long increaseBytes); synchronized void flush(); long getInstantBytesPerSecondAndFlush(); synchronized long getBytesPerSecondAndFlush(); synchronized long getBytesPerSecondFromBegin(); synchronized void endTask(); String instantSpeed(); String speed(); String lastSpeed(); synchronized long getInstantSpeedDurationMillis(); String getSpeedWithBinaryAndFlush(); String getSpeedWithSIAndFlush(); String averageSpeed(); String speedFromBegin(); }### Answer:
@Test public void getSpeedWithSIAndFlush() { doReturn(1054L).when(calculator).getInstantBytesPerSecondAndFlush(); assertThat(calculator.getSpeedWithSIAndFlush()).isEqualTo("1.1 kB/s"); } |
### Question:
DownloadListener4 implements DownloadListener,
Listener4Assist.Listener4Callback, ListenerAssist { @Override public boolean isAlwaysRecoverAssistModel() { return assist.isAlwaysRecoverAssistModel(); } DownloadListener4(Listener4Assist assist); DownloadListener4(); void setAssistExtend(@NonNull Listener4Assist.AssistExtend assistExtend); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override final void downloadFromBeginning(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override final void downloadFromBreakpoint(@NonNull DownloadTask task,
@NonNull BreakpointInfo info); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void fetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void isAlwaysRecoverAssistModel() { when(assist.isAlwaysRecoverAssistModel()).thenReturn(true); assertThat(listener4.isAlwaysRecoverAssistModel()).isTrue(); when(assist.isAlwaysRecoverAssistModel()).thenReturn(false); assertThat(listener4.isAlwaysRecoverAssistModel()).isFalse(); } |
### Question:
DownloadListener4 implements DownloadListener,
Listener4Assist.Listener4Callback, ListenerAssist { @Override public void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel) { assist.setAlwaysRecoverAssistModel(isAlwaysRecoverAssistModel); } DownloadListener4(Listener4Assist assist); DownloadListener4(); void setAssistExtend(@NonNull Listener4Assist.AssistExtend assistExtend); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override final void downloadFromBeginning(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override final void downloadFromBreakpoint(@NonNull DownloadTask task,
@NonNull BreakpointInfo info); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void fetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void setAlwaysRecoverAssistModel() { listener4.setAlwaysRecoverAssistModel(true); verify(assist).setAlwaysRecoverAssistModel(eq(true)); listener4.setAlwaysRecoverAssistModel(false); verify(assist).setAlwaysRecoverAssistModel(eq(false)); } |
### Question:
DownloadListener4 implements DownloadListener,
Listener4Assist.Listener4Callback, ListenerAssist { @Override public void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel) { assist.setAlwaysRecoverAssistModelIfNotSet(isAlwaysRecoverAssistModel); } DownloadListener4(Listener4Assist assist); DownloadListener4(); void setAssistExtend(@NonNull Listener4Assist.AssistExtend assistExtend); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override final void downloadFromBeginning(@NonNull DownloadTask task,
@NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override final void downloadFromBreakpoint(@NonNull DownloadTask task,
@NonNull BreakpointInfo info); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void fetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void setAlwaysRecoverAssistModelIfNotSet() { listener4.setAlwaysRecoverAssistModelIfNotSet(true); verify(assist).setAlwaysRecoverAssistModelIfNotSet(eq(true)); listener4.setAlwaysRecoverAssistModelIfNotSet(false); verify(assist).setAlwaysRecoverAssistModelIfNotSet(eq(false)); } |
### Question:
Listener4SpeedAssistExtend implements Listener4Assist.AssistExtend,
ListenerModelHandler.ModelCreator<Listener4SpeedAssistExtend.Listener4SpeedModel> { @Override public boolean dispatchFetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes, @NonNull Listener4Assist.Listener4Model model) { final Listener4SpeedModel speedModel = (Listener4SpeedModel) model; speedModel.blockSpeeds.get(blockIndex).downloading(increaseBytes); speedModel.taskSpeed.downloading(increaseBytes); if (callback != null) { callback.progressBlock(task, blockIndex, model.blockCurrentOffsetMap.get(blockIndex), speedModel.getBlockSpeed(blockIndex)); callback.progress(task, model.currentOffset, speedModel.taskSpeed); } return true; } void setCallback(Listener4SpeedCallback callback); @Override boolean dispatchInfoReady(DownloadTask task, @NonNull BreakpointInfo info,
boolean fromBreakpoint,
@NonNull Listener4Assist.Listener4Model model); @Override boolean dispatchFetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes,
@NonNull Listener4Assist.Listener4Model model); @Override boolean dispatchBlockEnd(DownloadTask task, int blockIndex,
Listener4Assist.Listener4Model model); @Override boolean dispatchTaskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause,
@NonNull Listener4Assist.Listener4Model model); @Override Listener4SpeedModel create(int id); }### Answer:
@Test public void dispatchFetchProgress() { final boolean result = assistExtend.dispatchFetchProgress(task, 0, 1L, model); assertThat(result).isTrue(); verify(model.blockSpeeds.get(0)).downloading(eq(1L)); verify(model.blockSpeeds.get(1), never()).downloading(eq(1L)); verify(model.blockSpeeds.get(2), never()).downloading(eq(1L)); verify(model.taskSpeed).downloading(eq(1L)); verify(callback).progressBlock(eq(task), eq(0), eq(model.blockCurrentOffsetMap.get(0)), eq(model.getBlockSpeed(0))); } |
### Question:
Listener4SpeedAssistExtend implements Listener4Assist.AssistExtend,
ListenerModelHandler.ModelCreator<Listener4SpeedAssistExtend.Listener4SpeedModel> { @Override public boolean dispatchBlockEnd(DownloadTask task, int blockIndex, Listener4Assist.Listener4Model model) { final Listener4SpeedModel speedModel = (Listener4SpeedModel) model; speedModel.blockSpeeds.get(blockIndex).endTask(); if (callback != null) { callback.blockEnd(task, blockIndex, model.info.getBlock(blockIndex), speedModel.getBlockSpeed(blockIndex)); } return true; } void setCallback(Listener4SpeedCallback callback); @Override boolean dispatchInfoReady(DownloadTask task, @NonNull BreakpointInfo info,
boolean fromBreakpoint,
@NonNull Listener4Assist.Listener4Model model); @Override boolean dispatchFetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes,
@NonNull Listener4Assist.Listener4Model model); @Override boolean dispatchBlockEnd(DownloadTask task, int blockIndex,
Listener4Assist.Listener4Model model); @Override boolean dispatchTaskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause,
@NonNull Listener4Assist.Listener4Model model); @Override Listener4SpeedModel create(int id); }### Answer:
@Test public void dispatchBlockEnd() { final boolean result = assistExtend.dispatchBlockEnd(task, 0, model); assertThat(result).isTrue(); verify(model.blockSpeeds.get(0)).endTask(); verify(callback) .blockEnd(task, eq(0), info.getBlock(0), model.getBlockSpeed(0)); } |
### Question:
Listener4SpeedAssistExtend implements Listener4Assist.AssistExtend,
ListenerModelHandler.ModelCreator<Listener4SpeedAssistExtend.Listener4SpeedModel> { @Override public boolean dispatchTaskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause, @NonNull Listener4Assist.Listener4Model model) { final Listener4SpeedModel speedModel = (Listener4SpeedModel) model; final SpeedCalculator speedCalculator; if (speedModel.taskSpeed != null) { speedCalculator = speedModel.taskSpeed; speedCalculator.endTask(); } else { speedCalculator = new SpeedCalculator(); } if (callback != null) { callback.taskEnd(task, cause, realCause, speedCalculator); } return true; } void setCallback(Listener4SpeedCallback callback); @Override boolean dispatchInfoReady(DownloadTask task, @NonNull BreakpointInfo info,
boolean fromBreakpoint,
@NonNull Listener4Assist.Listener4Model model); @Override boolean dispatchFetchProgress(@NonNull DownloadTask task, int blockIndex,
long increaseBytes,
@NonNull Listener4Assist.Listener4Model model); @Override boolean dispatchBlockEnd(DownloadTask task, int blockIndex,
Listener4Assist.Listener4Model model); @Override boolean dispatchTaskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause,
@NonNull Listener4Assist.Listener4Model model); @Override Listener4SpeedModel create(int id); }### Answer:
@Test public void dispatchTaskEnd() { final boolean result = assistExtend.dispatchTaskEnd(task, EndCause.COMPLETED, null, model); assertThat(result).isTrue(); verify(model.taskSpeed).endTask(); verify(callback).taskEnd(eq(task), eq(EndCause.COMPLETED), nullable(Exception.class), eq(model.taskSpeed)); }
@Test public void dispatchTaskEnd_withUnValidModel() { final Listener4SpeedAssistExtend.Listener4SpeedModel invalidModel = new Listener4SpeedAssistExtend.Listener4SpeedModel(1); assertThat(invalidModel.blockSpeeds).isEqualTo(null); assertThat(invalidModel.taskSpeed).isEqualTo(null); final boolean result = assistExtend.dispatchTaskEnd( task, EndCause.CANCELED, null, invalidModel); assertThat(result).isTrue(); verify(callback).taskEnd(eq(task), eq(EndCause.CANCELED), nullable(Exception.class), (SpeedCalculator) notNull()); } |
### Question:
Listener4Assist implements ListenerAssist { public void setCallback(@NonNull Listener4Callback callback) { this.callback = callback; } Listener4Assist(ListenerModelHandler<T> handler); Listener4Assist(ListenerModelHandler.ModelCreator<T> creator); void setCallback(@NonNull Listener4Callback callback); void setAssistExtend(@NonNull AssistExtend assistExtend); AssistExtend getAssistExtend(); void infoReady(DownloadTask task, BreakpointInfo info, boolean fromBreakpoint); void fetchProgress(DownloadTask task, int blockIndex, long increaseBytes); void fetchEnd(DownloadTask task, int blockIndex); synchronized void taskEnd(DownloadTask task, EndCause cause,
@Nullable Exception realCause); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); }### Answer:
@Test public void setCallback() { assist.setCallback(callback); assertThat(assist.callback).isEqualTo(callback); } |
### Question:
Listener4Assist implements ListenerAssist { public void setAssistExtend(@NonNull AssistExtend assistExtend) { this.assistExtend = assistExtend; } Listener4Assist(ListenerModelHandler<T> handler); Listener4Assist(ListenerModelHandler.ModelCreator<T> creator); void setCallback(@NonNull Listener4Callback callback); void setAssistExtend(@NonNull AssistExtend assistExtend); AssistExtend getAssistExtend(); void infoReady(DownloadTask task, BreakpointInfo info, boolean fromBreakpoint); void fetchProgress(DownloadTask task, int blockIndex, long increaseBytes); void fetchEnd(DownloadTask task, int blockIndex); synchronized void taskEnd(DownloadTask task, EndCause cause,
@Nullable Exception realCause); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); }### Answer:
@Test public void setAssistExtend() { assist.setAssistExtend(assistExtend); assertThat(assist.getAssistExtend()).isEqualTo(assistExtend); } |
### Question:
Listener4Assist implements ListenerAssist { public void infoReady(DownloadTask task, BreakpointInfo info, boolean fromBreakpoint) { final Listener4Model model = modelHandler.addAndGetModel(task, info); if (assistExtend != null && assistExtend .dispatchInfoReady(task, info, fromBreakpoint, model)) { return; } if (callback != null) callback.infoReady(task, info, fromBreakpoint, model); } Listener4Assist(ListenerModelHandler<T> handler); Listener4Assist(ListenerModelHandler.ModelCreator<T> creator); void setCallback(@NonNull Listener4Callback callback); void setAssistExtend(@NonNull AssistExtend assistExtend); AssistExtend getAssistExtend(); void infoReady(DownloadTask task, BreakpointInfo info, boolean fromBreakpoint); void fetchProgress(DownloadTask task, int blockIndex, long increaseBytes); void fetchEnd(DownloadTask task, int blockIndex); synchronized void taskEnd(DownloadTask task, EndCause cause,
@Nullable Exception realCause); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); }### Answer:
@Test public void infoReady_dispatch() { when(assistExtend.dispatchInfoReady(eq(task), eq(info), eq(true), any(Listener4Assist.Listener4Model.class))) .thenReturn(true); assist.infoReady(task, info, true); verify(assist.callback, never()).infoReady(eq(task), eq(info), eq(true), any(Listener4Assist.Listener4Model.class)); verify(handler).addAndGetModel(eq(task), eq(info)); }
@Test public void infoReady_noDispatch() { when(handler.addAndGetModel(task, info)).thenReturn(model); when(assistExtend.dispatchInfoReady(eq(task), eq(info), eq(true), any(Listener4Assist.Listener4Model.class))) .thenReturn(false); assist.infoReady(task, info, true); verify(assist.callback).infoReady(eq(task), eq(info), eq(true), eq(model)); verify(handler).addAndGetModel(eq(task), eq(info)); } |
### Question:
SpeedCalculator { public String averageSpeed() { return speedFromBegin(); } synchronized void reset(); synchronized void downloading(long increaseBytes); synchronized void flush(); long getInstantBytesPerSecondAndFlush(); synchronized long getBytesPerSecondAndFlush(); synchronized long getBytesPerSecondFromBegin(); synchronized void endTask(); String instantSpeed(); String speed(); String lastSpeed(); synchronized long getInstantSpeedDurationMillis(); String getSpeedWithBinaryAndFlush(); String getSpeedWithSIAndFlush(); String averageSpeed(); String speedFromBegin(); }### Answer:
@Test public void averageSpeed() { doReturn("1").when(calculator).speedFromBegin(); assertThat(calculator.averageSpeed()).isEqualTo("1"); } |
### Question:
DownloadSerialQueue extends DownloadListener2 implements Runnable { public synchronized void enqueue(DownloadTask task) { taskList.add(task); Collections.sort(taskList); if (!paused && !looping) { looping = true; startNewLooper(); } } DownloadSerialQueue(); DownloadSerialQueue(DownloadListener listener, ArrayList<DownloadTask> taskList); DownloadSerialQueue(DownloadListener listener); void setListener(DownloadListener listener); synchronized void enqueue(DownloadTask task); synchronized void pause(); synchronized void resume(); int getWorkingTaskId(); int getWaitingTaskCount(); synchronized DownloadTask[] shutdown(); @Override void run(); @Override void taskStart(@NonNull DownloadTask task); @Override synchronized void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void enqueue() { doNothing().when(serialQueue).startNewLooper(); when(task1.compareTo(task2)).thenReturn(-1); serialQueue.enqueue(task2); serialQueue.enqueue(task1); verify(taskList).add(eq(task1)); verify(taskList).add(eq(task2)); assertThat(taskList).containsExactly(task1, task2); } |
### Question:
Listener4Assist implements ListenerAssist { public void fetchProgress(DownloadTask task, int blockIndex, long increaseBytes) { final Listener4Model model = modelHandler.getOrRecoverModel(task, task.getInfo()); if (model == null) return; final long blockCurrentOffset = model.blockCurrentOffsetMap .get(blockIndex) + increaseBytes; model.blockCurrentOffsetMap.put(blockIndex, blockCurrentOffset); model.currentOffset += increaseBytes; if (assistExtend != null && assistExtend.dispatchFetchProgress(task, blockIndex, increaseBytes, model)) { return; } if (callback != null) { callback.progressBlock(task, blockIndex, blockCurrentOffset); callback.progress(task, model.currentOffset); } } Listener4Assist(ListenerModelHandler<T> handler); Listener4Assist(ListenerModelHandler.ModelCreator<T> creator); void setCallback(@NonNull Listener4Callback callback); void setAssistExtend(@NonNull AssistExtend assistExtend); AssistExtend getAssistExtend(); void infoReady(DownloadTask task, BreakpointInfo info, boolean fromBreakpoint); void fetchProgress(DownloadTask task, int blockIndex, long increaseBytes); void fetchEnd(DownloadTask task, int blockIndex); synchronized void taskEnd(DownloadTask task, EndCause cause,
@Nullable Exception realCause); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); }### Answer:
@Test public void fetchProgress_noModel() { when(handler.getOrRecoverModel(task, info)).thenReturn(null); assist.fetchProgress(task, 0, 0); verify(callback, never()).progress(eq(task), eq(0L)); verify(assistExtend, never()).dispatchFetchProgress(eq(task), eq(0), eq(0L), any(Listener4Assist.Listener4Model.class)); verify(handler).getOrRecoverModel(eq(task), eq(info)); }
@Test public void fetchProgress_dispatch() { when(handler.getOrRecoverModel(task, info)).thenReturn(model); final int blockIndex = 0; final long increaseBytes = 2L; when(assistExtend.dispatchFetchProgress(eq(task), eq(blockIndex), eq(increaseBytes), any(Listener4Assist.Listener4Model.class))) .thenReturn(true); assist.fetchProgress(task, blockIndex, increaseBytes); verify(callback, never()).progress(eq(task), anyLong()); verify(callback, never()).progressBlock(eq(task), eq(0), anyLong()); verify(handler).getOrRecoverModel(eq(task), eq(info)); }
@Test public void fetchProgress() { when(handler.getOrRecoverModel(task, info)).thenReturn(model); assist.fetchProgress(task, 0, 3); assertThat(model.getCurrentOffset()).isEqualTo(3); assertThat(model.getBlockCurrentOffsetMap().get(0)).isEqualTo(3); assertThat(model.getBlockCurrentOffsetMap().get(1)).isEqualTo(0); assertThat(model.getBlockCurrentOffsetMap().get(2)).isEqualTo(0); verify(callback).progressBlock(eq(task), eq(0), eq(3L)); verify(callback).progress(eq(task), eq(3L)); verify(handler).getOrRecoverModel(eq(task), eq(info)); assist.fetchProgress(task, 1, 2); assertThat(model.getCurrentOffset()).isEqualTo(5); assertThat(model.getBlockCurrentOffsetMap().get(1)).isEqualTo(2); verify(callback).progressBlock(eq(task), eq(1), eq(2L)); verify(callback).progress(eq(task), eq(5L)); } |
### Question:
Listener4Assist implements ListenerAssist { public void fetchEnd(DownloadTask task, int blockIndex) { final Listener4Model model = modelHandler.getOrRecoverModel(task, task.getInfo()); if (model == null) return; if (assistExtend != null && assistExtend.dispatchBlockEnd(task, blockIndex, model)) { return; } if (callback != null) { callback.blockEnd(task, blockIndex, model.info.getBlock(blockIndex)); } } Listener4Assist(ListenerModelHandler<T> handler); Listener4Assist(ListenerModelHandler.ModelCreator<T> creator); void setCallback(@NonNull Listener4Callback callback); void setAssistExtend(@NonNull AssistExtend assistExtend); AssistExtend getAssistExtend(); void infoReady(DownloadTask task, BreakpointInfo info, boolean fromBreakpoint); void fetchProgress(DownloadTask task, int blockIndex, long increaseBytes); void fetchEnd(DownloadTask task, int blockIndex); synchronized void taskEnd(DownloadTask task, EndCause cause,
@Nullable Exception realCause); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); }### Answer:
@Test public void fetchEnd_dispatch() { when(handler.getOrRecoverModel(task, info)).thenReturn(model); final int blockIndex = 0; when(assistExtend.dispatchBlockEnd(eq(task), eq(blockIndex), any( Listener4Assist.Listener4Model.class))).thenReturn(true); assist.fetchEnd(task, blockIndex); verify(callback, never()).blockEnd(eq(task), eq(blockIndex), any(BlockInfo.class)); verify(handler).getOrRecoverModel(eq(task), eq(info)); }
@Test public void fetchEnd() { when(handler.getOrRecoverModel(task, info)).thenReturn(model); assist.fetchEnd(task, 1); final BlockInfo blockInfo1 = info.getBlock(1); verify(callback).blockEnd(eq(task), eq(1), eq(blockInfo1)); verify(handler).getOrRecoverModel(eq(task), eq(info)); } |
### Question:
Listener4Assist implements ListenerAssist { public synchronized void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause) { Listener4Model model = modelHandler.removeOrCreate(task, task.getInfo()); if (assistExtend != null && assistExtend.dispatchTaskEnd(task, cause, realCause, model)) { return; } if (callback != null) callback.taskEnd(task, cause, realCause, model); } Listener4Assist(ListenerModelHandler<T> handler); Listener4Assist(ListenerModelHandler.ModelCreator<T> creator); void setCallback(@NonNull Listener4Callback callback); void setAssistExtend(@NonNull AssistExtend assistExtend); AssistExtend getAssistExtend(); void infoReady(DownloadTask task, BreakpointInfo info, boolean fromBreakpoint); void fetchProgress(DownloadTask task, int blockIndex, long increaseBytes); void fetchEnd(DownloadTask task, int blockIndex); synchronized void taskEnd(DownloadTask task, EndCause cause,
@Nullable Exception realCause); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); }### Answer:
@Test public void taskEnd_dispatch() { when(handler.removeOrCreate(task, info)).thenReturn(model); when(assistExtend.dispatchTaskEnd(eq(task), any(EndCause.class), nullable(Exception.class), any(Listener4Assist.Listener4Model.class))) .thenReturn(true); assist.taskEnd(task, EndCause.COMPLETED, null); verify(callback, never()) .taskEnd(eq(task), eq(EndCause.COMPLETED), nullable(Exception.class), any(Listener4Assist.Listener4Model.class)); }
@Test public void taskEnd_noModel() { when(handler.removeOrCreate(task, info)).thenReturn(model); assist.taskEnd(task, EndCause.COMPLETED, null); verify(callback).taskEnd(eq(task), eq(EndCause.COMPLETED), nullable(Exception.class), any(Listener4Assist.Listener4Model.class)); } |
### Question:
Listener4Assist implements ListenerAssist { @Override public boolean isAlwaysRecoverAssistModel() { return modelHandler.isAlwaysRecoverAssistModel(); } Listener4Assist(ListenerModelHandler<T> handler); Listener4Assist(ListenerModelHandler.ModelCreator<T> creator); void setCallback(@NonNull Listener4Callback callback); void setAssistExtend(@NonNull AssistExtend assistExtend); AssistExtend getAssistExtend(); void infoReady(DownloadTask task, BreakpointInfo info, boolean fromBreakpoint); void fetchProgress(DownloadTask task, int blockIndex, long increaseBytes); void fetchEnd(DownloadTask task, int blockIndex); synchronized void taskEnd(DownloadTask task, EndCause cause,
@Nullable Exception realCause); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); }### Answer:
@Test public void isAlwaysRecoverAssistModel() { when(handler.isAlwaysRecoverAssistModel()).thenReturn(true); assertThat(assist.isAlwaysRecoverAssistModel()).isTrue(); when(handler.isAlwaysRecoverAssistModel()).thenReturn(false); assertThat(assist.isAlwaysRecoverAssistModel()).isFalse(); } |
### Question:
Listener4Assist implements ListenerAssist { @Override public void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel) { modelHandler.setAlwaysRecoverAssistModel(isAlwaysRecoverAssistModel); } Listener4Assist(ListenerModelHandler<T> handler); Listener4Assist(ListenerModelHandler.ModelCreator<T> creator); void setCallback(@NonNull Listener4Callback callback); void setAssistExtend(@NonNull AssistExtend assistExtend); AssistExtend getAssistExtend(); void infoReady(DownloadTask task, BreakpointInfo info, boolean fromBreakpoint); void fetchProgress(DownloadTask task, int blockIndex, long increaseBytes); void fetchEnd(DownloadTask task, int blockIndex); synchronized void taskEnd(DownloadTask task, EndCause cause,
@Nullable Exception realCause); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); }### Answer:
@Test public void setAlwaysRecoverAssistModel() { assist.setAlwaysRecoverAssistModel(true); verify(handler).setAlwaysRecoverAssistModel(eq(true)); assist.setAlwaysRecoverAssistModel(false); verify(handler).setAlwaysRecoverAssistModel(eq(false)); } |
### Question:
SpeedCalculator { public String speedFromBegin() { return humanReadableSpeed(getBytesPerSecondFromBegin(), true); } synchronized void reset(); synchronized void downloading(long increaseBytes); synchronized void flush(); long getInstantBytesPerSecondAndFlush(); synchronized long getBytesPerSecondAndFlush(); synchronized long getBytesPerSecondFromBegin(); synchronized void endTask(); String instantSpeed(); String speed(); String lastSpeed(); synchronized long getInstantSpeedDurationMillis(); String getSpeedWithBinaryAndFlush(); String getSpeedWithSIAndFlush(); String averageSpeed(); String speedFromBegin(); }### Answer:
@Test public void speedFromBegin() { doReturn(1L).when(calculator).getBytesPerSecondFromBegin(); assertThat(calculator.speedFromBegin()).isEqualTo("1 B/s"); } |
### Question:
Listener4Assist implements ListenerAssist { @Override public void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel) { modelHandler.setAlwaysRecoverAssistModelIfNotSet(isAlwaysRecoverAssistModel); } Listener4Assist(ListenerModelHandler<T> handler); Listener4Assist(ListenerModelHandler.ModelCreator<T> creator); void setCallback(@NonNull Listener4Callback callback); void setAssistExtend(@NonNull AssistExtend assistExtend); AssistExtend getAssistExtend(); void infoReady(DownloadTask task, BreakpointInfo info, boolean fromBreakpoint); void fetchProgress(DownloadTask task, int blockIndex, long increaseBytes); void fetchEnd(DownloadTask task, int blockIndex); synchronized void taskEnd(DownloadTask task, EndCause cause,
@Nullable Exception realCause); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); }### Answer:
@Test public void setAlwaysRecoverAssistModelIfNotSet() { assist.setAlwaysRecoverAssistModelIfNotSet(true); verify(handler).setAlwaysRecoverAssistModelIfNotSet(eq(true)); assist.setAlwaysRecoverAssistModelIfNotSet(false); verify(handler).setAlwaysRecoverAssistModelIfNotSet(eq(false)); } |
### Question:
ListenerModelHandler implements
ListenerAssist { @NonNull T addAndGetModel(@NonNull DownloadTask task, @Nullable BreakpointInfo info) { T model = creator.create(task.getId()); synchronized (this) { if (singleTaskModel == null) { singleTaskModel = model; } else { modelList.put(task.getId(), model); } if (info != null) { model.onInfoValid(info); } } return model; } ListenerModelHandler(ModelCreator<T> creator); boolean isAlwaysRecoverAssistModel(); void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); }### Answer:
@Test public void addAndGetModel_provideInfo() { final ListenerModelHandler.ListenerModel model = handler.addAndGetModel(task, info); assertThat(model).isEqualTo(this.model); verify(creator).create(anyInt()); assertThat(handler.singleTaskModel).isEqualTo(model); assertThat(handler.modelList.size()).isZero(); verify(model).onInfoValid(eq(info)); handler.addAndGetModel(task, info); assertThat(handler.modelList.size()).isOne(); }
@Test public void addAndGetModel_noInfo() { final ListenerModelHandler.ListenerModel model = handler.addAndGetModel(task, null); assertThat(model).isEqualTo(this.model); verify(creator).create(anyInt()); assertThat(handler.singleTaskModel).isEqualTo(model); assertThat(handler.modelList.size()).isZero(); verify(model, never()).onInfoValid(eq(info)); } |
### Question:
ListenerModelHandler implements
ListenerAssist { @NonNull T removeOrCreate(@NonNull DownloadTask task, @Nullable BreakpointInfo info) { final int id = task.getId(); T model; synchronized (this) { if (singleTaskModel != null && singleTaskModel.getId() == id) { model = singleTaskModel; singleTaskModel = null; } else { model = modelList.get(id); modelList.remove(id); } } if (model == null) { model = creator.create(id); if (info != null) { model.onInfoValid(info); } } return model; } ListenerModelHandler(ModelCreator<T> creator); boolean isAlwaysRecoverAssistModel(); void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); }### Answer:
@Test public void removeOrCreate_withInfo() { handler.singleTaskModel = model; assertThat(handler.removeOrCreate(task, info)).isEqualTo(model); verify(creator, never()).create(anyInt()); verify(model, never()).onInfoValid(eq(info)); handler.singleTaskModel = null; handler.modelList.put(task.getId(), model); assertThat(handler.removeOrCreate(task, info)).isEqualTo(model); verify(creator, never()).create(anyInt()); verify(model, never()).onInfoValid(eq(info)); handler.modelList.clear(); assertThat(handler.removeOrCreate(task, info)).isEqualTo(model); verify(creator).create(anyInt()); verify(model).onInfoValid(eq(info)); }
@Test public void removeOrCreate_noInfo() { handler.modelList.clear(); assertThat(handler.removeOrCreate(task, null)).isEqualTo(model); verify(creator).create(anyInt()); verify(model, never()).onInfoValid(any(BreakpointInfo.class)); } |
### Question:
Listener1Assist implements ListenerAssist,
ListenerModelHandler.ModelCreator<Listener1Assist.Listener1Model> { public void taskStart(DownloadTask task) { final Listener1Model model = modelHandler.addAndGetModel(task, null); if (callback != null) callback.taskStart(task, model); } Listener1Assist(); Listener1Assist(ListenerModelHandler<Listener1Model> handler); void setCallback(@NonNull Listener1Callback callback); void taskStart(DownloadTask task); void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause); void downloadFromBeginning(DownloadTask task,
@NonNull BreakpointInfo info,
ResumeFailedCause cause); void downloadFromBreakpoint(DownloadTask task, @NonNull BreakpointInfo info); void connectEnd(DownloadTask task); void fetchProgress(DownloadTask task, long increaseBytes); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override Listener1Model create(int id); }### Answer:
@Test public void taskStart() { when(handler.addAndGetModel(task, null)).thenReturn(model); assist.taskStart(task); verify(callback).taskStart(eq(task), eq(model)); } |
### Question:
Listener1Assist implements ListenerAssist,
ListenerModelHandler.ModelCreator<Listener1Assist.Listener1Model> { public void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause) { Listener1Model model = modelHandler.removeOrCreate(task, task.getInfo()); if (callback != null) callback.taskEnd(task, cause, realCause, model); } Listener1Assist(); Listener1Assist(ListenerModelHandler<Listener1Model> handler); void setCallback(@NonNull Listener1Callback callback); void taskStart(DownloadTask task); void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause); void downloadFromBeginning(DownloadTask task,
@NonNull BreakpointInfo info,
ResumeFailedCause cause); void downloadFromBreakpoint(DownloadTask task, @NonNull BreakpointInfo info); void connectEnd(DownloadTask task); void fetchProgress(DownloadTask task, long increaseBytes); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override Listener1Model create(int id); }### Answer:
@Test public void taskEnd() { when(handler.removeOrCreate(task, info)).thenReturn(model); assist.taskEnd(task, EndCause.COMPLETED, null); verify(handler).removeOrCreate(eq(task), nullable(BreakpointInfo.class)); verify(callback).taskEnd(eq(task), eq(EndCause.COMPLETED), nullable(Exception.class), eq(model)); } |
### Question:
Listener1Assist implements ListenerAssist,
ListenerModelHandler.ModelCreator<Listener1Assist.Listener1Model> { public void downloadFromBeginning(DownloadTask task, @NonNull BreakpointInfo info, ResumeFailedCause cause) { final Listener1Model model = modelHandler.getOrRecoverModel(task, info); if (model == null) return; model.onInfoValid(info); if (model.isStarted && callback != null) { callback.retry(task, cause); } model.isStarted = true; model.isFromResumed = false; model.isFirstConnect = true; } Listener1Assist(); Listener1Assist(ListenerModelHandler<Listener1Model> handler); void setCallback(@NonNull Listener1Callback callback); void taskStart(DownloadTask task); void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause); void downloadFromBeginning(DownloadTask task,
@NonNull BreakpointInfo info,
ResumeFailedCause cause); void downloadFromBreakpoint(DownloadTask task, @NonNull BreakpointInfo info); void connectEnd(DownloadTask task); void fetchProgress(DownloadTask task, long increaseBytes); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override Listener1Model create(int id); }### Answer:
@Test public void downloadFromBeginning() { when(handler.getOrRecoverModel(task, info)).thenReturn(null); assist.downloadFromBeginning(task, info, cause); verify(model, never()).onInfoValid(eq(info)); Listener1Assist.Listener1Model model = spy(new Listener1Assist.Listener1Model(1)); when(handler.getOrRecoverModel(task, info)).thenReturn(model); assist.downloadFromBeginning(task, info, cause); verify(model).onInfoValid(eq(info)); model = new Listener1Assist.Listener1Model(1); when(handler.getOrRecoverModel(task, info)).thenReturn(model); assist.downloadFromBeginning(task, info, cause); assertThat(model.isStarted).isTrue(); assertThat(model.isFromResumed).isFalse(); assertThat(model.isFirstConnect).isTrue(); verify(callback, never()).retry(eq(task), eq(cause)); model.isStarted = true; when(handler.getOrRecoverModel(task, info)).thenReturn(model); assist.downloadFromBeginning(task, info, cause); verify(callback).retry(eq(task), eq(cause)); } |
### Question:
Listener1Assist implements ListenerAssist,
ListenerModelHandler.ModelCreator<Listener1Assist.Listener1Model> { public void downloadFromBreakpoint(DownloadTask task, @NonNull BreakpointInfo info) { final Listener1Model model = modelHandler.getOrRecoverModel(task, info); if (model == null) return; model.onInfoValid(info); model.isStarted = true; model.isFromResumed = true; model.isFirstConnect = true; } Listener1Assist(); Listener1Assist(ListenerModelHandler<Listener1Model> handler); void setCallback(@NonNull Listener1Callback callback); void taskStart(DownloadTask task); void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause); void downloadFromBeginning(DownloadTask task,
@NonNull BreakpointInfo info,
ResumeFailedCause cause); void downloadFromBreakpoint(DownloadTask task, @NonNull BreakpointInfo info); void connectEnd(DownloadTask task); void fetchProgress(DownloadTask task, long increaseBytes); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override Listener1Model create(int id); }### Answer:
@Test public void downloadFromBreakpoint() { when(handler.getOrRecoverModel(task, info)).thenReturn(null); assist.downloadFromBreakpoint(task, info); verify(model, never()).onInfoValid(eq(info)); when(handler.getOrRecoverModel(task, info)).thenReturn(model); assist.downloadFromBreakpoint(task, info); verify(model).onInfoValid(eq(info)); final Listener1Assist.Listener1Model model = new Listener1Assist.Listener1Model(1); when(handler.getOrRecoverModel(task, info)).thenReturn(model); assist.downloadFromBreakpoint(task, info); assertThat(model.isStarted).isTrue(); assertThat(model.isFromResumed).isTrue(); assertThat(model.isFirstConnect).isTrue(); } |
### Question:
Listener1Assist implements ListenerAssist,
ListenerModelHandler.ModelCreator<Listener1Assist.Listener1Model> { public void connectEnd(DownloadTask task) { final Listener1Model model = modelHandler.getOrRecoverModel(task, task.getInfo()); if (model == null) return; if (model.isFromResumed && model.isFirstConnect) { model.isFirstConnect = false; } if (callback != null) { callback.connected(task, model.blockCount, model.currentOffset.get(), model.totalLength); } } Listener1Assist(); Listener1Assist(ListenerModelHandler<Listener1Model> handler); void setCallback(@NonNull Listener1Callback callback); void taskStart(DownloadTask task); void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause); void downloadFromBeginning(DownloadTask task,
@NonNull BreakpointInfo info,
ResumeFailedCause cause); void downloadFromBreakpoint(DownloadTask task, @NonNull BreakpointInfo info); void connectEnd(DownloadTask task); void fetchProgress(DownloadTask task, long increaseBytes); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override Listener1Model create(int id); }### Answer:
@Test public void connectEnd() { when(handler.getOrRecoverModel(task, info)).thenReturn(null); assist.connectEnd(task); verify(callback, never()).connected(eq(task), anyInt(), anyLong(), anyLong()); final Listener1Assist.Listener1Model model = new Listener1Assist.Listener1Model(1); model.onInfoValid(info); model.blockCount = 1; model.currentOffset.set(2); model.totalLength = 3; when(handler.getOrRecoverModel(task, info)).thenReturn(model); assist.connectEnd(task); verify(callback).connected(eq(task), eq(1), eq(2L), eq(3L)); model.isFromResumed = true; model.isFirstConnect = true; assist.connectEnd(task); assertThat(model.isFirstConnect).isFalse(); } |
### Question:
StatusUtil { public static Status getStatus(@NonNull DownloadTask task) { final Status status = isCompletedOrUnknown(task); if (status == Status.COMPLETED) return Status.COMPLETED; final DownloadDispatcher dispatcher = OkDownload.with().downloadDispatcher(); if (dispatcher.isPending(task)) return Status.PENDING; if (dispatcher.isRunning(task)) return Status.RUNNING; return status; } static boolean isSameTaskPendingOrRunning(@NonNull DownloadTask task); static Status getStatus(@NonNull DownloadTask task); static Status getStatus(@NonNull String url, @NonNull String parentPath,
@Nullable String filename); static boolean isCompleted(@NonNull DownloadTask task); static Status isCompletedOrUnknown(@NonNull DownloadTask task); static boolean isCompleted(@NonNull String url, @NonNull String parentPath,
@Nullable String filename); @Nullable static BreakpointInfo getCurrentInfo(@NonNull String url,
@NonNull String parentPath,
@Nullable String filename); @Nullable static BreakpointInfo getCurrentInfo(@NonNull DownloadTask task); }### Answer:
@Test public void getStatus() throws IOException { file.getParentFile().mkdirs(); file.createNewFile(); assertThat(file.exists()).isTrue(); StatusUtil.Status status = StatusUtil .getStatus(url, file.getParent(), file.getName()); assertThat(status).isEqualTo(COMPLETED); status = StatusUtil.getStatus(url, file.getParentFile().getPath(), null); assertThat(status).isEqualTo(UNKNOWN); final DownloadDispatcher dispatcher = OkDownload.with().downloadDispatcher(); doReturn(true).when(dispatcher).isRunning(any(DownloadTask.class)); status = StatusUtil.getStatus(url, file.getParentFile().getPath(), null); assertThat(status).isEqualTo(RUNNING); doReturn(true).when(dispatcher).isPending(any(DownloadTask.class)); status = StatusUtil.getStatus(url, file.getParentFile().getPath(), null); assertThat(status).isEqualTo(PENDING); } |
### Question:
Listener1Assist implements ListenerAssist,
ListenerModelHandler.ModelCreator<Listener1Assist.Listener1Model> { public void fetchProgress(DownloadTask task, long increaseBytes) { final Listener1Model model = modelHandler.getOrRecoverModel(task, task.getInfo()); if (model == null) return; model.currentOffset.addAndGet(increaseBytes); if (callback != null) callback.progress(task, model.currentOffset.get(), model.totalLength); } Listener1Assist(); Listener1Assist(ListenerModelHandler<Listener1Model> handler); void setCallback(@NonNull Listener1Callback callback); void taskStart(DownloadTask task); void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause); void downloadFromBeginning(DownloadTask task,
@NonNull BreakpointInfo info,
ResumeFailedCause cause); void downloadFromBreakpoint(DownloadTask task, @NonNull BreakpointInfo info); void connectEnd(DownloadTask task); void fetchProgress(DownloadTask task, long increaseBytes); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override Listener1Model create(int id); }### Answer:
@Test public void fetchProgress() { when(handler.getOrRecoverModel(task, info)).thenReturn(null); assist.fetchProgress(task, 1); verify(callback, never()).progress(eq(task), anyLong(), anyLong()); final Listener1Assist.Listener1Model model = new Listener1Assist.Listener1Model(1); model.currentOffset.set(2); model.totalLength = 3; when(handler.getOrRecoverModel(task, info)).thenReturn(model); assist.fetchProgress(task, 1); verify(callback).progress(eq(task), eq(2L + 1L), eq(3L)); } |
### Question:
Listener1Assist implements ListenerAssist,
ListenerModelHandler.ModelCreator<Listener1Assist.Listener1Model> { @Override public boolean isAlwaysRecoverAssistModel() { return modelHandler.isAlwaysRecoverAssistModel(); } Listener1Assist(); Listener1Assist(ListenerModelHandler<Listener1Model> handler); void setCallback(@NonNull Listener1Callback callback); void taskStart(DownloadTask task); void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause); void downloadFromBeginning(DownloadTask task,
@NonNull BreakpointInfo info,
ResumeFailedCause cause); void downloadFromBreakpoint(DownloadTask task, @NonNull BreakpointInfo info); void connectEnd(DownloadTask task); void fetchProgress(DownloadTask task, long increaseBytes); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override Listener1Model create(int id); }### Answer:
@Test public void isAlwaysRecoverAssistModel() { when(handler.isAlwaysRecoverAssistModel()).thenReturn(true); assertThat(assist.isAlwaysRecoverAssistModel()).isTrue(); when(handler.isAlwaysRecoverAssistModel()).thenReturn(false); assertThat(assist.isAlwaysRecoverAssistModel()).isFalse(); } |
### Question:
Listener1Assist implements ListenerAssist,
ListenerModelHandler.ModelCreator<Listener1Assist.Listener1Model> { @Override public void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel) { modelHandler.setAlwaysRecoverAssistModel(isAlwaysRecoverAssistModel); } Listener1Assist(); Listener1Assist(ListenerModelHandler<Listener1Model> handler); void setCallback(@NonNull Listener1Callback callback); void taskStart(DownloadTask task); void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause); void downloadFromBeginning(DownloadTask task,
@NonNull BreakpointInfo info,
ResumeFailedCause cause); void downloadFromBreakpoint(DownloadTask task, @NonNull BreakpointInfo info); void connectEnd(DownloadTask task); void fetchProgress(DownloadTask task, long increaseBytes); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override Listener1Model create(int id); }### Answer:
@Test public void setAlwaysRecoverAssistModel() { assist.setAlwaysRecoverAssistModel(true); verify(handler).setAlwaysRecoverAssistModel(eq(true)); assist.setAlwaysRecoverAssistModel(false); verify(handler).setAlwaysRecoverAssistModel(eq(false)); } |
### Question:
Listener1Assist implements ListenerAssist,
ListenerModelHandler.ModelCreator<Listener1Assist.Listener1Model> { @Override public void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel) { modelHandler.setAlwaysRecoverAssistModelIfNotSet(isAlwaysRecoverAssistModel); } Listener1Assist(); Listener1Assist(ListenerModelHandler<Listener1Model> handler); void setCallback(@NonNull Listener1Callback callback); void taskStart(DownloadTask task); void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause); void downloadFromBeginning(DownloadTask task,
@NonNull BreakpointInfo info,
ResumeFailedCause cause); void downloadFromBreakpoint(DownloadTask task, @NonNull BreakpointInfo info); void connectEnd(DownloadTask task); void fetchProgress(DownloadTask task, long increaseBytes); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override Listener1Model create(int id); }### Answer:
@Test public void setAlwaysRecoverAssistModelIfNotSet() { assist.setAlwaysRecoverAssistModelIfNotSet(true); verify(handler).setAlwaysRecoverAssistModelIfNotSet(eq(true)); assist.setAlwaysRecoverAssistModelIfNotSet(false); verify(handler).setAlwaysRecoverAssistModelIfNotSet(eq(false)); } |
### Question:
DownloadListener2 implements DownloadListener { @Override public void connectTrialStart(@NonNull DownloadTask task, @NonNull Map<String, List<String>> requestHeaderFields) { } @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); }### Answer:
@Test public void connectTrialStart() throws Exception { listener2.connectTrialStart(task, headerFields); } |
### Question:
DownloadListener2 implements DownloadListener { @Override public void connectTrialEnd(@NonNull DownloadTask task, int responseCode, @NonNull Map<String, List<String>> responseHeaderFields) { } @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); }### Answer:
@Test public void connectTrialEnd() throws Exception { listener2.connectTrialEnd(task, 200, headerFields); } |
### Question:
DownloadListener2 implements DownloadListener { @Override public void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info, @NonNull ResumeFailedCause cause) { } @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); }### Answer:
@Test public void downloadFromBeginning() throws Exception { listener2.downloadFromBeginning(task, info, cause); } |
### Question:
DownloadListener2 implements DownloadListener { @Override public void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info) { } @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); }### Answer:
@Test public void downloadFromBreakpoint() throws Exception { listener2.downloadFromBreakpoint(task, info); } |
### Question:
DownloadListener2 implements DownloadListener { @Override public void connectStart(@NonNull DownloadTask task, int blockIndex, @NonNull Map<String, List<String>> requestHeaderFields) { } @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); }### Answer:
@Test public void connectStart() throws Exception { listener2.connectStart(task, 1, headerFields); } |
### Question:
DownloadListener2 implements DownloadListener { @Override public void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode, @NonNull Map<String, List<String>> responseHeaderFields) { } @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); }### Answer:
@Test public void connectEnd() throws Exception { listener2.connectEnd(task, 1, 200, headerFields); } |
### Question:
StatusUtil { public static boolean isCompleted(@NonNull DownloadTask task) { return isCompletedOrUnknown(task) == Status.COMPLETED; } static boolean isSameTaskPendingOrRunning(@NonNull DownloadTask task); static Status getStatus(@NonNull DownloadTask task); static Status getStatus(@NonNull String url, @NonNull String parentPath,
@Nullable String filename); static boolean isCompleted(@NonNull DownloadTask task); static Status isCompletedOrUnknown(@NonNull DownloadTask task); static boolean isCompleted(@NonNull String url, @NonNull String parentPath,
@Nullable String filename); @Nullable static BreakpointInfo getCurrentInfo(@NonNull String url,
@NonNull String parentPath,
@Nullable String filename); @Nullable static BreakpointInfo getCurrentInfo(@NonNull DownloadTask task); }### Answer:
@Test public void isCompleted() throws IOException { assertThat(file.exists()).isFalse(); boolean isCompleted = StatusUtil .isCompleted(url, file.getParentFile().getPath(), file.getName()); assertThat(isCompleted).isFalse(); file.getParentFile().mkdirs(); file.createNewFile(); isCompleted = StatusUtil .isCompleted(url, file.getParentFile().getPath(), file.getName()); assertThat(isCompleted).isTrue(); final BreakpointStore store = OkDownload.with().breakpointStore(); doReturn(mock(BreakpointInfo.class)).when(store).get(anyInt()); isCompleted = StatusUtil .isCompleted(url, file.getParentFile().getPath(), file.getName()); assertThat(isCompleted).isFalse(); } |
### Question:
DownloadListener2 implements DownloadListener { @Override public void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength) { } @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); }### Answer:
@Test public void fetchStart() throws Exception { listener2.fetchStart(task, 1, 2); } |
### Question:
DownloadListener2 implements DownloadListener { @Override public void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes) { } @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); }### Answer:
@Test public void fetchProgress() throws Exception { listener2.fetchProgress(task, 1, 2); } |
### Question:
DownloadListener2 implements DownloadListener { @Override public void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength) { } @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); }### Answer:
@Test public void fetchEnd() throws Exception { listener2.fetchEnd(task, 1, 2); } |
### Question:
DownloadListener1 implements DownloadListener,
Listener1Assist.Listener1Callback, ListenerAssist { @Override public final void taskStart(@NonNull DownloadTask task) { assist.taskStart(task); } DownloadListener1(Listener1Assist assist); DownloadListener1(); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override final void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void taskStart() { listener1.taskStart(task); verify(listener1.assist).taskStart(eq(task)); } |
### Question:
DownloadListener1 implements DownloadListener,
Listener1Assist.Listener1Callback, ListenerAssist { @Override public void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info, @NonNull ResumeFailedCause cause) { assist.downloadFromBeginning(task, info, cause); } DownloadListener1(Listener1Assist assist); DownloadListener1(); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override final void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void downloadFromBeginning() { final ResumeFailedCause cause = mock(ResumeFailedCause.class); listener1.downloadFromBeginning(task, info, cause); verify(listener1.assist).downloadFromBeginning(eq(task), eq(info), eq(cause)); } |
### Question:
DownloadListener1 implements DownloadListener,
Listener1Assist.Listener1Callback, ListenerAssist { @Override public void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info) { assist.downloadFromBreakpoint(task, info); } DownloadListener1(Listener1Assist assist); DownloadListener1(); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override final void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void downloadFromBreakpoint() { listener1.downloadFromBreakpoint(task, info); verify(listener1.assist).downloadFromBreakpoint(eq(task), eq(info)); } |
### Question:
DownloadListener1 implements DownloadListener,
Listener1Assist.Listener1Callback, ListenerAssist { @Override public void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode, @NonNull Map<String, List<String>> responseHeaderFields) { assist.connectEnd(task); } DownloadListener1(Listener1Assist assist); DownloadListener1(); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override final void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void connectEnd() { listener1.connectEnd(task, 1, 200, tmpFields); verify(listener1.assist).connectEnd(eq(task)); } |
### Question:
DownloadListener1 implements DownloadListener,
Listener1Assist.Listener1Callback, ListenerAssist { @Override public void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes) { assist.fetchProgress(task, increaseBytes); } DownloadListener1(Listener1Assist assist); DownloadListener1(); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override final void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void fetchProgress() { listener1.fetchProgress(task, 1, 2); verify(listener1.assist).fetchProgress(eq(task), eq(2L)); } |
### Question:
DownloadListener1 implements DownloadListener,
Listener1Assist.Listener1Callback, ListenerAssist { @Override public boolean isAlwaysRecoverAssistModel() { return assist.isAlwaysRecoverAssistModel(); } DownloadListener1(Listener1Assist assist); DownloadListener1(); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override final void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void isAlwaysRecoverAssistModel() { when(assist.isAlwaysRecoverAssistModel()).thenReturn(true); assertThat(listener1.isAlwaysRecoverAssistModel()).isTrue(); when(assist.isAlwaysRecoverAssistModel()).thenReturn(false); assertThat(listener1.isAlwaysRecoverAssistModel()).isFalse(); } |
### Question:
DownloadListener1 implements DownloadListener,
Listener1Assist.Listener1Callback, ListenerAssist { @Override public void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel) { assist.setAlwaysRecoverAssistModel(isAlwaysRecoverAssistModel); } DownloadListener1(Listener1Assist assist); DownloadListener1(); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override final void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void setAlwaysRecoverAssistModel() { listener1.setAlwaysRecoverAssistModel(true); verify(assist).setAlwaysRecoverAssistModel(eq(true)); listener1.setAlwaysRecoverAssistModel(false); verify(assist).setAlwaysRecoverAssistModel(eq(false)); } |
### Question:
DownloadListener1 implements DownloadListener,
Listener1Assist.Listener1Callback, ListenerAssist { @Override public void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel) { assist.setAlwaysRecoverAssistModelIfNotSet(isAlwaysRecoverAssistModel); } DownloadListener1(Listener1Assist assist); DownloadListener1(); @Override boolean isAlwaysRecoverAssistModel(); @Override void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel); @Override void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel); @Override final void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); }### Answer:
@Test public void setAlwaysRecoverAssistModelIfNotSet() { listener1.setAlwaysRecoverAssistModelIfNotSet(true); verify(assist).setAlwaysRecoverAssistModelIfNotSet(eq(true)); listener1.setAlwaysRecoverAssistModelIfNotSet(false); verify(assist).setAlwaysRecoverAssistModelIfNotSet(eq(false)); } |
### Question:
DownloadListenerBunch implements DownloadListener { @Override public void taskStart(@NonNull DownloadTask task) { for (DownloadListener listener : listenerList) { listener.taskStart(task); } } DownloadListenerBunch(@NonNull DownloadListener[] listenerList); @Override void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); boolean contain(DownloadListener targetListener); int indexOf(DownloadListener targetListener); }### Answer:
@Test public void taskStart() throws Exception { listenerBunch.taskStart(task); verify(listener1).taskStart(eq(task)); verify(listener2).taskStart(eq(task)); } |
### Question:
DownloadListenerBunch implements DownloadListener { @Override public void connectTrialStart(@NonNull DownloadTask task, @NonNull Map<String, List<String>> requestHeaderFields) { for (DownloadListener listener : listenerList) { listener.connectTrialStart(task, requestHeaderFields); } } DownloadListenerBunch(@NonNull DownloadListener[] listenerList); @Override void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); boolean contain(DownloadListener targetListener); int indexOf(DownloadListener targetListener); }### Answer:
@Test public void connectTrialStart() throws Exception { listenerBunch.connectTrialStart(task, headerFields); verify(listener1).connectTrialStart(eq(task), eq(headerFields)); verify(listener2).connectTrialStart(eq(task), eq(headerFields)); } |
### Question:
DownloadListenerBunch implements DownloadListener { @Override public void connectTrialEnd(@NonNull DownloadTask task, int responseCode, @NonNull Map<String, List<String>> responseHeaderFields) { for (DownloadListener listener : listenerList) { listener.connectTrialEnd(task, responseCode, responseHeaderFields); } } DownloadListenerBunch(@NonNull DownloadListener[] listenerList); @Override void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); boolean contain(DownloadListener targetListener); int indexOf(DownloadListener targetListener); }### Answer:
@Test public void connectTrialEnd() throws Exception { listenerBunch.connectTrialEnd(task, 200, headerFields); verify(listener1).connectTrialEnd(eq(task), eq(200), eq(headerFields)); verify(listener2).connectTrialEnd(eq(task), eq(200), eq(headerFields)); } |
### Question:
DownloadListenerBunch implements DownloadListener { @Override public void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info, @NonNull ResumeFailedCause cause) { for (DownloadListener listener : listenerList) { listener.downloadFromBeginning(task, info, cause); } } DownloadListenerBunch(@NonNull DownloadListener[] listenerList); @Override void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); boolean contain(DownloadListener targetListener); int indexOf(DownloadListener targetListener); }### Answer:
@Test public void downloadFromBeginning() throws Exception { listenerBunch.downloadFromBeginning(task, info, resumeFailedCause); verify(listener1).downloadFromBeginning(eq(task), eq(info), eq(resumeFailedCause)); verify(listener2).downloadFromBeginning(eq(task), eq(info), eq(resumeFailedCause)); } |
### Question:
DownloadListenerBunch implements DownloadListener { @Override public void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info) { for (DownloadListener listener : listenerList) { listener.downloadFromBreakpoint(task, info); } } DownloadListenerBunch(@NonNull DownloadListener[] listenerList); @Override void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); boolean contain(DownloadListener targetListener); int indexOf(DownloadListener targetListener); }### Answer:
@Test public void downloadFromBreakpoint() throws Exception { listenerBunch.downloadFromBreakpoint(task, info); verify(listener1).downloadFromBreakpoint(eq(task), eq(info)); verify(listener2).downloadFromBreakpoint(eq(task), eq(info)); } |
### Question:
DownloadListenerBunch implements DownloadListener { @Override public void connectStart(@NonNull DownloadTask task, int blockIndex, @NonNull Map<String, List<String>> requestHeaderFields) { for (DownloadListener listener : listenerList) { listener.connectStart(task, blockIndex, requestHeaderFields); } } DownloadListenerBunch(@NonNull DownloadListener[] listenerList); @Override void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); boolean contain(DownloadListener targetListener); int indexOf(DownloadListener targetListener); }### Answer:
@Test public void connectStart() throws Exception { listenerBunch.connectStart(task, 1, headerFields); verify(listener1).connectStart(eq(task), eq(1), eq(headerFields)); verify(listener2).connectStart(eq(task), eq(1), eq(headerFields)); } |
### Question:
DownloadListenerBunch implements DownloadListener { @Override public void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode, @NonNull Map<String, List<String>> responseHeaderFields) { for (DownloadListener listener : listenerList) { listener.connectEnd(task, blockIndex, responseCode, responseHeaderFields); } } DownloadListenerBunch(@NonNull DownloadListener[] listenerList); @Override void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); boolean contain(DownloadListener targetListener); int indexOf(DownloadListener targetListener); }### Answer:
@Test public void connectEnd() throws Exception { listenerBunch.connectEnd(task, 1, 1, headerFields); verify(listener1).connectEnd(eq(task), eq(1), eq(1), eq(headerFields)); verify(listener2).connectEnd(eq(task), eq(1), eq(1), eq(headerFields)); } |
### Question:
DownloadListenerBunch implements DownloadListener { @Override public void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength) { for (DownloadListener listener : listenerList) { listener.fetchStart(task, blockIndex, contentLength); } } DownloadListenerBunch(@NonNull DownloadListener[] listenerList); @Override void taskStart(@NonNull DownloadTask task); @Override void connectTrialStart(@NonNull DownloadTask task,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectTrialEnd(@NonNull DownloadTask task, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
@NonNull ResumeFailedCause cause); @Override void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info); @Override void connectStart(@NonNull DownloadTask task, int blockIndex,
@NonNull Map<String, List<String>> requestHeaderFields); @Override void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode,
@NonNull Map<String, List<String>> responseHeaderFields); @Override void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes); @Override void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength); @Override void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
@Nullable Exception realCause); boolean contain(DownloadListener targetListener); int indexOf(DownloadListener targetListener); }### Answer:
@Test public void fetchStart() throws Exception { listenerBunch.fetchStart(task, 1, 1L); verify(listener1).fetchStart(eq(task), eq(1), eq(1L)); verify(listener2).fetchStart(eq(task), eq(1), eq(1L)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.