@Test (expected = IllegalArgumentException.class) public void tickFail() { scheduler.tick(scheduler.getLastTickTime() - 1); fail("Exception should have been thrown"); }
@Test public void executeHighPriorityTest() { TestableScheduler highScheduler = new TestableScheduler(); TestableScheduler lowScheduler = new TestableScheduler(); PriorityDelegatingScheduler delegatingScheduler = new PriorityDelegatingScheduler(highScheduler, lowScheduler, null, TaskPriority.Starvable); delegatingScheduler.execute(DoNothingRunnable.instance(), TaskPriority.High); assertEquals(1, highScheduler.tick()); assertEquals(0, lowScheduler.tick()); }
@Test public void lastTickTimeTest() { long now = Clock.lastKnownTimeMillis(); scheduler.tick(now + 1000); assertEquals(now + 1000, scheduler.getLastTickTime()); }
@Test public void interceptExecuteTest() { executorInterceptor.execute(tr); assertEquals(1, testInterceptor.getInterceptedTasks().size()); assertTrue(tr == testInterceptor.getInterceptedTasks().get(0)); assertEquals(1, scheduler.tick()); // replaced task should run assertEquals(0, tr.getRunCount()); // should have been replaced and not run }
@Test public void interceptExecuteWithPriorityTest() { priorityInterceptor.execute(tr, TaskPriority.Low); assertEquals(1, testInterceptor.getInterceptedTasks().size()); assertTrue(tr == testInterceptor.getInterceptedTasks().get(0)); assertEquals(1, scheduler.tick()); // replaced task should run assertEquals(0, tr.getRunCount()); // should have been replaced and not run }
@Test public void interceptSubmitCallableTest() { ListenableFuture<?> f = executorInterceptor.submit(new TestCallable()); assertEquals(1, testInterceptor.getInterceptedTasks().size()); assertTrue(testInterceptor.getInterceptedTasks().get(0) instanceof ListenableFutureTask); assertEquals(1, scheduler.tick()); // replaced task should run assertFalse(f.isDone()); }
@Test public void interceptSubmitRunnableWithResultWithPriorityTest() throws InterruptedException, ExecutionException { Object result = new Object(); ListenableFuture<?> f = priorityInterceptor.submit(tr, result, TaskPriority.Low); assertEquals(1, testInterceptor.getInterceptedTasks().size()); assertTrue(tr == testInterceptor.getInterceptedTasks().get(0)); assertEquals(1, scheduler.tick()); // replaced task should run assertEquals(0, tr.getRunCount()); // should have been replaced and not run assertTrue(f.isDone()); assertTrue(f.get() == result); }
@Test public void interceptSubmitRunnableWithResultTest() throws InterruptedException, ExecutionException { Object result = new Object(); ListenableFuture<?> f = executorInterceptor.submit(tr, result); assertEquals(1, testInterceptor.getInterceptedTasks().size()); assertTrue(tr == testInterceptor.getInterceptedTasks().get(0)); assertEquals(1, scheduler.tick()); // replaced task should run assertEquals(0, tr.getRunCount()); // should have been replaced and not run assertTrue(f.isDone()); assertTrue(f.get() == result); }
@Test public void interceptSubmitRunnableWithPriorityTest() { ListenableFuture<?> f = priorityInterceptor.submit(tr, TaskPriority.Low); assertEquals(1, testInterceptor.getInterceptedTasks().size()); assertTrue(tr == testInterceptor.getInterceptedTasks().get(0)); assertEquals(1, scheduler.tick()); // replaced task should run assertEquals(0, tr.getRunCount()); // should have been replaced and not run assertTrue(f.isDone()); }
@Test public void interceptSubmitRunnableTest() { ListenableFuture<?> f = executorInterceptor.submit(tr); assertEquals(1, testInterceptor.getInterceptedTasks().size()); assertTrue(tr == testInterceptor.getInterceptedTasks().get(0)); assertEquals(1, scheduler.tick()); // replaced task should run assertEquals(0, tr.getRunCount()); // should have been replaced and not run assertTrue(f.isDone()); }
@Test public void tickWithoutHandlerThrowsRuntimeExceptionTest() { RuntimeException failure = new SuppressedStackRuntimeException(); scheduler.execute(new TestRuntimeFailureRunnable(failure)); try { scheduler.tick(); fail("Exception should have thrown"); } catch (Exception e) { assertTrue(e == failure); } }
private static void starvablePriorityIgnoredTest(boolean ignored) { TestableScheduler testableScheduler = new TestableScheduler(); PrioritySchedulerServiceQueueLimitRejector queueRejector = new PrioritySchedulerServiceQueueLimitRejector(testableScheduler, TEST_QTY, ignored); for (int i = 0; i < TEST_QTY; i++) { assertEquals(ignored ? 0 : i, queueRejector.getQueuedTaskCount()); queueRejector.execute(DoNothingRunnable.instance(), TaskPriority.Starvable); } assertEquals(TEST_QTY, testableScheduler.tick()); }
@Test public void expiredFutureTest() { SettableListenableFuture<Object> slf = new SettableListenableFuture<>(); watchdog.watch(slf, TIMEOUT); TestUtils.blockTillClockAdvances(); assertEquals(1, scheduler.tick()); assertTrue(slf.isCancelled()); }
@Test public void getQueuedTaskCountTest() { TestableScheduler testableScheduler = new TestableScheduler(); ExecutorQueueLimitRejector queueRejector = new ExecutorQueueLimitRejector(testableScheduler, TEST_QTY); for (int i = 0; i < TEST_QTY; i++) { assertEquals(i, queueRejector.getQueuedTaskCount()); queueRejector.execute(DoNothingRunnable.instance()); } testableScheduler.tick(); assertEquals(0, queueRejector.getQueuedTaskCount()); }
@Override @Test public void getQueuedTaskCountTest() { TestableScheduler testableScheduler = new TestableScheduler(); SchedulerServiceQueueLimitRejector queueRejector = new SchedulerServiceQueueLimitRejector(testableScheduler, TEST_QTY); for (int i = 0; i < TEST_QTY; i++) { assertEquals(i, queueRejector.getQueuedTaskCount()); queueRejector.execute(DoNothingRunnable.instance()); } testableScheduler.tick(); assertEquals(0, queueRejector.getQueuedTaskCount()); }
@Test public void advanceThenTickTest() { scheduler.execute(DoNothingRunnable.instance()); scheduler.advance(1000 * 10); TestRunnable tr = new TestRunnable(); scheduler.execute(tr); assertEquals(1, scheduler.tick()); assertTrue(tr.ranOnce()); }
@Test public void flatMapWithExecutorAlreadyDoneMapperThrowExceptionTest() throws InterruptedException { TestableScheduler scheduler = new TestableScheduler(); RuntimeException failure = new SuppressedStackRuntimeException(); ListenableFuture<?> lf = makeListenableFutureFactory().makeWithResult(null); ListenableFuture<Void> mappedLF = lf.flatMap((o) -> { throw failure; }, scheduler); assertEquals(1, scheduler.tick()); assertTrue(mappedLF.isDone()); verifyFutureFailure(mappedLF, failure); }
@Test public void getQueuedTaskCountTest() { assertEquals(0, statWrapper.getQueuedTaskCount()); TestableScheduler scheduler = new TestableScheduler(); statWrapper = new ExecutorStatisticWrapper(scheduler); statWrapper.execute(DoNothingRunnable.instance()); assertEquals(1, statWrapper.getQueuedTaskCount()); scheduler.tick(); assertEquals(0, statWrapper.getQueuedTaskCount()); }
@Test public void flatMapWithExecutorAlreadyDoneMapperReturnFailedFutureTest() throws InterruptedException { TestableScheduler scheduler = new TestableScheduler(); RuntimeException failure = new SuppressedStackRuntimeException(); ListenableFuture<?> lf = makeListenableFutureFactory().makeWithResult(null); ListenableFuture<Void> mappedLF = lf.flatMap((o) -> FutureUtils.immediateFailureFuture(failure), scheduler); assertEquals(1, scheduler.tick()); assertTrue(mappedLF.isDone()); verifyFutureFailure(mappedLF, failure); }