private static List<TestRunnable> getRunnableList() { List<TestRunnable> result = new ArrayList<>(TEST_QTY); for (int i = 0; i < TEST_QTY; i++) { result.add(new TestRunnable()); } return result; }
@Test public void invokeTwiceTest() { TestRunnable tr1 = new TestRunnable(); TestRunnable tr2 = new TestRunnable(); Runnable r = InvocationTee.tee(Runnable.class, tr1, null, tr2, null); r.run(); r.run(); assertEquals(2, tr1.getRunCount()); assertEquals(2, tr2.getRunCount()); }
@Test public void addListenerTest() { TestFutureImp future = new TestFutureImp(false); ScheduledFutureDelegate<?> testItem = new ScheduledFutureDelegate<>(future, null); TestRunnable firstListener = new TestRunnable(); TestRunnable secondListener = new TestRunnable(); future.addListener(firstListener); testItem.addListener(secondListener); assertEquals(2, future.listeners.size()); assertTrue(future.listeners.contains(firstListener)); assertTrue(future.listeners.contains(secondListener)); }
@Test public void invokeWithExceptionThrowingTest() { TestRunnable tr = new TestRunnable(); Runnable r = InvocationTee.teeWithExceptionThrowing(Runnable.class, null, tr); r.run(); // should run just like the normal version assertTrue(tr.ranOnce()); }
@Test public void getLongRunningTasksTest() { assertTrue(statWrapper.getLongRunningTasks(-1).isEmpty()); statWrapper.execute(new TestRunnable() { @Override public void handleRunStart() { assertEquals(1, statWrapper.getLongRunningTasks(-1).size()); assertTrue(statWrapper.getLongRunningTasks(10).isEmpty()); } }); }
@Before public void setup() { scheduler = new TestableScheduler(); executorInterceptor = new TestExecutorInterceptor(scheduler); testInterceptor = (TestInterceptor)executorInterceptor; tr = new TestRunnable(); }
@Test public void invokeAfterAllCompleteEmptyListTest() { List<ListenableFuture<?>> futures = Collections.emptyList(); TestRunnable tr = new TestRunnable(); FutureUtils.invokeAfterAllComplete(futures, tr); assertTrue(tr.ranOnce()); }
@Test public void runTest() { TestRunnable tr = new TestRunnable(); Runnable tsr = new ThrowableSuppressingRunnable(tr); tsr.run(); assertTrue(tr.ranOnce()); }
public static void addListenerTest(ListenableFuture<?> testFuture) { TestRunnable tr = new TestRunnable(); testFuture.addListener(tr); assertTrue(tr.ranOnce()); tr = new TestRunnable(); testFuture.addListener(tr, null); assertTrue(tr.ranOnce()); tr = new TestRunnable(); testFuture.addListener(tr, new SameThreadSubmitterExecutor()); assertTrue(tr.ranOnce()); }
@Test public void getNextTaskExecuteFirstTest() { OneTimeTaskWrapper executeTask = new OneTimeTaskWrapper(DoNothingRunnable.instance(), null, Clock.accurateForwardProgressingMillis()); OneTimeTaskWrapper scheduleTask = new OneTimeTaskWrapper(new TestRunnable(), null, Clock.accurateForwardProgressingMillis() + DELAY_TIME); queueSet.executeQueue.add(executeTask); queueSet.scheduleQueue.add(scheduleTask); assertTrue(queueSet.getNextTask() == executeTask); }
@Test @SuppressWarnings("deprecation") public void runRunnableTest() { TestRunnable tr = new TestRunnable(); ExceptionUtils.runRunnable(tr); assertTrue(tr.ranOnce()); }
@Test public void getContainedRunnableTest() { TestRunnable tr = new TestRunnable(); ThrowableSuppressingRunnable tsr = new ThrowableSuppressingRunnable(tr); assertTrue(tsr.getContainedRunnable() == tr); }
private void removeRunnableTest(TaskPriority priority) { AbstractPrioritySchedulerFactory factory = getAbstractPrioritySchedulerFactory(); try { AbstractPriorityScheduler scheduler = factory.makeAbstractPriorityScheduler(1); TestRunnable removedTask = new TestRunnable(); scheduler.submitScheduled(removedTask, 10 * 1000, priority); assertFalse(scheduler.remove(new TestRunnable())); assertTrue(scheduler.remove(removedTask)); } finally { factory.shutdown(); } }
@Test public void callTest() { TestRunnable tr = new TestRunnable(); Object result = new Object(); RunnableCallableAdapter<?> rca = (RunnableCallableAdapter<?>)RunnableCallableAdapter.adapt(tr, result); assertTrue(result == rca.call()); assertTrue(tr.ranOnce()); }
@Test public void invokeAfterAllCompleteTest() { List<SettableListenableFuture<Void>> futures = Collections.singletonList(new SettableListenableFuture<>()); TestRunnable tr = new TestRunnable(); FutureUtils.invokeAfterAllComplete(futures, tr); assertEquals(0, tr.getRunCount()); futures.get(0).setResult(null); assertTrue(tr.ranOnce()); }
public static void getWithPriorityAverageExecutionDurationNoInputTest(StatisticPriorityScheduler scheduler) { TestRunnable tr = new TestRunnable(); scheduler.execute(tr, TaskPriority.Low); tr.blockTillFinished(); blockTillSchedulerIdle(scheduler, 1); assertEquals(-1, scheduler.getAverageExecutionDuration(TaskPriority.High), 0); }
@Test public void isDoneTest() { ExecuteOnGetFutureFactory ff = makeFutureFactory(); TestRunnable r = new TestRunnable(); RunnableFuture<?> future = ff.make(r); future.run(); assertTrue(future.isDone()); }
@Test public void executeOnceTest() throws InterruptedException, ExecutionException { TestRunnable tr = new TestRunnable(); ExecuteOnGetFutureTask<?> geft = new ExecuteOnGetFutureTask<>(tr); geft.get(); geft.run(); geft.get(); // multiple get calls should not execute again either geft.run(); assertTrue(tr.ranOnce()); }
@Test public void getAverageExecutionDurationTest() { assertEquals(-1, statWrapper.getAverageExecutionDuration(), 0); statWrapper.execute(DoNothingRunnable.instance()); assertEquals(1, statWrapper.getAverageExecutionDuration(), 1); statWrapper.execute(new TestRunnable(DELAY_TIME)); assertTrue(statWrapper.getAverageExecutionDuration() >= DELAY_TIME / 2); }
@Test public void runnableScheduleWhileFirstRunInThreadTest() throws Exception { int scheduleDelayMillis = 10; TestableScheduler scheduler = new TestableScheduler(); TestRunnable tr = new TestRunnable(); ListenableFuture<?> f = FutureUtils.scheduleWhile(scheduler, scheduleDelayMillis, false, tr, () -> tr.getRunCount() < 2); assertFalse(f.isDone()); assertEquals(1, scheduler.advance(scheduleDelayMillis)); assertTrue(f.isDone()); assertNull(f.get()); // verify no error state }