/** Test the method isDone() */ @Test public void testIsDoneMethod() throws Exception { Callable<String> task = new BasicTestTask(); IExecutorService executor = createSingleNodeExecutorService("isDoneMethod"); Future future = executor.submit(task); if (future.isDone()) { assertTrue(future.isDone()); } assertEquals(future.get(), BasicTestTask.RESULT); assertTrue(future.isDone()); }
/** Test for the issue 129. Repeatedly runs tasks and check for isDone() status after get(). */ @Test public void testIsDoneMethod2() throws Exception { ExecutorService executor = createSingleNodeExecutorService("isDoneMethod2"); for (int i = 0; i < COUNT; i++) { Callable<String> task1 = new BasicTestTask(); Callable<String> task2 = new BasicTestTask(); Future future1 = executor.submit(task1); Future future2 = executor.submit(task2); assertEquals(future2.get(), BasicTestTask.RESULT); assertTrue(future2.isDone()); assertEquals(future1.get(), BasicTestTask.RESULT); assertTrue(future1.isDone()); } }
public static <V> boolean areAllTrue(List<Future<V>> results) { for (Future<V> result : results) { if (!result.isDone()) { return false; } } return true; }
/** Test multiple Future.get() invocation */ @Test public void testMultipleFutureGets() throws Exception { Callable<String> task = new BasicTestTask(); ExecutorService executor = createSingleNodeExecutorService("isTwoGetFromFuture"); Future<String> future = executor.submit(task); String s1 = future.get(); assertEquals(s1, BasicTestTask.RESULT); assertTrue(future.isDone()); String s2 = future.get(); assertEquals(s2, BasicTestTask.RESULT); assertTrue(future.isDone()); String s3 = future.get(); assertEquals(s3, BasicTestTask.RESULT); assertTrue(future.isDone()); String s4 = future.get(); assertEquals(s4, BasicTestTask.RESULT); assertTrue(future.isDone()); }
@Test public void testCancellationAwareTask2() { Callable task1 = new CancellationAwareTask(5000); ExecutorService executor = createSingleNodeExecutorService("testCancellationAwareTask", 1); executor.submit(task1); Callable task2 = new BasicTestTask(); Future future = executor.submit(task2); assertFalse(future.isDone()); assertTrue(future.cancel(true)); assertTrue(future.isCancelled()); assertTrue(future.isDone()); try { future.get(); fail("Should not complete the task successfully"); } catch (CancellationException expected) { } catch (Exception e) { fail("Unexpected exception " + e); } }
@Test public void testCancellationAwareTask() throws ExecutionException, InterruptedException { CancellationAwareTask task = new CancellationAwareTask(5000); ExecutorService executor = createSingleNodeExecutorService("testCancellationAwareTask"); Future future = executor.submit(task); try { future.get(2, TimeUnit.SECONDS); fail("Should throw TimeoutException!"); } catch (TimeoutException expected) { } assertFalse(future.isDone()); assertTrue(future.cancel(true)); assertTrue(future.isCancelled()); assertTrue(future.isDone()); try { future.get(); fail("Should not complete the task successfully"); } catch (CancellationException expected) { } catch (Exception e) { fail("Unexpected exception " + e); } }
public static void main(String[] args) { ActiveObjectDemo d1 = new ActiveObjectDemo(); // Prevents ConcurrentModificationException: List<Future<?>> results = new CopyOnWriteArrayList<Future<?>>(); for (float f = 0.0f; f < 1.0f; f += 0.2f) results.add(d1.calculateFloat(f, f)); for (int i = 0; i < 5; i++) results.add(d1.calculateInt(i, i)); print("All asynch calls made"); while (results.size() > 0) { for (Future<?> f : results) if (f.isDone()) { try { print(f.get()); } catch (Exception e) { throw new RuntimeException(e); } results.remove(f); } } d1.shutdown(); }
public void testAwaitTerminationMakesSureTasksTransferredToBackendExecutorAreFinished() throws InterruptedException, ExecutionException { final AppScheduledExecutorService service = new AppScheduledExecutorService(getName()); final List<LogInfo> log = Collections.synchronizedList(new ArrayList<>()); int N = 20; int delay = 500; List<? extends Future<?>> futures = ContainerUtil.map( Collections.nCopies(N, ""), s -> service.schedule( () -> { TimeoutUtil.sleep(5000); log.add(new LogInfo(0)); }, delay, TimeUnit.MILLISECONDS)); TimeoutUtil.sleep(delay); long start = System.currentTimeMillis(); while (!service.delayQueue.isEmpty() && System.currentTimeMillis() < start + 20000) { // wait till all tasks transferred to backend } List<SchedulingWrapper.MyScheduledFutureTask> queuedTasks = new ArrayList<>(service.delayQueue); if (!queuedTasks.isEmpty()) { String s = queuedTasks .stream() .map(BoundedTaskExecutor::info) .collect(Collectors.toList()) .toString(); fail("Queued tasks left: " + s + ";\n" + queuedTasks); } service.shutdownAppScheduledExecutorService(); assertTrue(service.awaitTermination(20, TimeUnit.SECONDS)); for (Future<?> future : futures) { assertTrue(future.isDone()); } assertEquals(log.toString(), N, log.size()); }
public void testDelayedWorks() throws InterruptedException { final AppScheduledExecutorService service = new AppScheduledExecutorService(getName()); final List<LogInfo> log = Collections.synchronizedList(new ArrayList<>()); assertFalse(service.isShutdown()); assertFalse(service.isTerminated()); service.invokeAll( Collections.nCopies( service.getBackendPoolCorePoolSize() + 1, Executors.callable(EmptyRunnable.getInstance()))); // pre-start all threads int delay = 1000; long start = System.currentTimeMillis(); ScheduledFuture<?> f1 = service.schedule( () -> { log.add(new LogInfo(1)); TimeoutUtil.sleep(10); }, delay, TimeUnit.MILLISECONDS); assertFalse(service.isShutdown()); assertFalse(service.isTerminated()); ScheduledFuture<?> f2 = service.schedule( () -> { log.add(new LogInfo(2)); TimeoutUtil.sleep(10); }, delay, TimeUnit.MILLISECONDS); assertFalse(service.isShutdown()); assertFalse(service.isTerminated()); ScheduledFuture<?> f3 = service.schedule( () -> { log.add(new LogInfo(3)); TimeoutUtil.sleep(10); }, delay, TimeUnit.MILLISECONDS); assertFalse(service.isShutdown()); assertFalse(service.isTerminated()); Future<?> f4 = service.submit((Runnable) () -> log.add(new LogInfo(4))); assertFalse(service.isShutdown()); assertFalse(service.isTerminated()); assertFalse(f1.isDone()); assertFalse(f2.isDone()); assertFalse(f3.isDone()); TimeoutUtil.sleep(delay / 2); long elapsed = System.currentTimeMillis() - start; // can be > delay/2 on overloaded agent assertEquals(String.valueOf(f1.isDone()), elapsed > delay, f1.isDone()); assertEquals(String.valueOf(f2.isDone()), elapsed > delay, f2.isDone()); assertEquals(String.valueOf(f3.isDone()), elapsed > delay, f3.isDone()); assertTrue(f4.isDone()); TimeoutUtil.sleep(delay / 2 + 500); assertTrue(f1.isDone()); assertTrue(f2.isDone()); assertTrue(f3.isDone()); assertTrue(f4.isDone()); assertEquals(4, log.size()); assertEquals(4, log.get(0).runnable); List<Thread> threads = Arrays.asList(log.get(1).currentThread, log.get(2).currentThread, log.get(3).currentThread); assertEquals( threads.toString(), 3, new HashSet<>(threads).size()); // must be executed in parallel service.shutdownAppScheduledExecutorService(); assertTrue(service.awaitTermination(10, TimeUnit.SECONDS)); }