/** * Helper public method (used by CDI module), disabled as some IDEs invoke it as a test method */ @Test(enabled = false) // Disable explicitly to avoid TestNG thinking this is a test!! public void basicInvocation(Runnable call) throws Exception { DistributedExecutorService des = createDES(getCache()); des.submit(call).get(); }
/** * Helper public method (used by CDI module), disabled as some IDEs invoke it as a test method */ @Test(enabled = false) // Disable explicitly to avoid TestNG thinking this is a test!! public void basicInvocation(Callable<Integer> call, Object... keys) throws Exception { DistributedExecutorService des = createDES(getCache()); Future<Integer> future = des.submit(call, keys); Integer r = future.get(); assertEquals((Integer) 1, r); }
public void testRunnableInvocation() throws Exception { DistributedExecutorService des = createDES(getCache()); Future<?> future = des.submit(new BoringRunnable()); Object object = future.get(); assertEquals(null, object); }
public void testRunnableInvocationWith2Params() throws Exception { DistributedExecutorService des = createDES(getCache()); Integer result = 5; Future<Integer> future = des.submit(new BoringRunnable(), result); assertEquals(result, future.get()); }
public void testBasicTargetCallableWithNullTarget() { Cache<Object, Object> cache1 = getCache(); DistributedExecutorService des = createDES(cache1); expectException(NullPointerException.class, () -> des.submit((Address) null, new SimpleCallable())); }
public void testBasicDistributedCallableWithNullTask() throws Exception { Cache<Object, Object> c1 = getCache(); DistributedExecutorService des = createDES(getCache()); DistributedTask task = null; expectException(NullPointerException.class, () -> des.submit(task, "key1", "key2")); }
public void testExceptionCallableWithTimedCall() throws Exception { DistributedExecutorService des = createDES(getCache()); Future<Integer> future = des.submit(new ExceptionThrowingCallable(latchHolder, true)); expectException(TimeoutException.class, () -> future.get(100, TimeUnit.MILLISECONDS)); latchHolder.get().open(); }
public void testCancelAndGet() throws Exception { DistributedExecutorService des = createDES(getCache()); List<Address> cacheMembers = getCache().getAdvancedCache().getRpcManager().getMembers(); List<Address> members = new ArrayList<>(cacheMembers); assertEquals(caches(cacheName()).size(), members.size()); members.remove(getCache().getAdvancedCache().getRpcManager().getAddress()); DistributedTaskBuilder<Integer> tb = des.createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); final Future<Integer> future = des.submit(members.get(0),tb.build()); future.cancel(true); expectException(CancellationException.class, () -> future.get()); latchHolder.get().open(); }
public void testSleepingCallableWithTimeoutExc() throws Exception { DistributedExecutorService des = createDES(getCache()); Future<Integer> future = des.submit(new SleepingSimpleCallable(latchHolder)); log.tracef("Sleeping task submitted"); expectException(TimeoutException.class, () -> future.get(100, TimeUnit.MILLISECONDS)); latchHolder.get().open(); }
public void testExceptionCallableWithTimedCallDistApi() throws Exception { DistributedExecutorService des = createDES(getCache()); DistributedTaskBuilder<Integer> taskBuilder = des.createDistributedTaskBuilder(new ExceptionThrowingCallable(latchHolder, true)); DistributedTask<Integer> distributedTask = taskBuilder.build(); Future<Integer> future = des.submit(distributedTask); expectException(TimeoutException.class, () -> future.get(10, TimeUnit.MILLISECONDS)); latchHolder.get().open(); }
public void testSleepingCallableWithTimeoutExcDistApi() throws Exception { DistributedExecutorService des = createDES(getCache()); DistributedTaskBuilder<Integer> taskBuilder = des.createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); DistributedTask<Integer> distributedTask = taskBuilder.build(); Future<Integer> future = des.submit(distributedTask); log.tracef("Sleeping task submitted"); expectException(TimeoutException.class, () -> future.get(100, TimeUnit.MILLISECONDS)); latchHolder.get().open(); }
public void testBasicTargetCallableWithNullTask() { Cache<Object, Object> cache1 = getCache(); DistributedExecutorService des = createDES(cache1); Address target = cache1.getAdvancedCache().getRpcManager().getAddress(); expectException(IllegalArgumentException.class, () -> des.submit(target, (Callable) null)); }
public void testBasicTargetDistributedTaskWithNullTask() { Cache<Object, Object> cache1 = getCache(); DistributedExecutorService des = createDES(cache1); Address target = cache1.getAdvancedCache().getRpcManager().getAddress(); expectException(NullPointerException.class, () -> des.submit(target, (DistributedTask) null)); }
public void testBasicTargetLocalDistributedCallableWithoutSpecTimeout() throws Exception { Cache<Object, Object> cache1 = cache(0, cacheName()); // initiate task from cache1 and execute on same node DistributedExecutorService des = createDES(cache1); Address target = cache1.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder builder = des .createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); Future<Integer> future = des.submit(target, builder.build()); Thread.sleep(100); latchHolder.get().open(); assertEquals((Integer) 1, future.get()); }
public void testTimeoutOnLocalNode() throws Exception { AdvancedCache<Object, Object> localCache = getCache().getAdvancedCache(); DistributedExecutorService des = createDES(localCache); Future<Integer> future = des.submit(localCache.getRpcManager().getAddress(), new SleepingSimpleCallable(latchHolder)); expectException(TimeoutException.class, () -> future.get(100, TimeUnit.MILLISECONDS)); latchHolder.get().open(); }
public void testBasicTargetLocalDistributedCallableWithTimeout() throws Exception { Cache<Object, Object> cache1 = getCache(); Cache<Object, Object> cache2 = cache(1, cacheName()); CyclicBarrier barrier = new CyclicBarrier(2); cache2.getAdvancedCache().getComponentRegistry().registerComponent(barrier, "barrier"); // initiate task from cache1 and execute on same node DistributedExecutorService des = createDES(cache1); Address target = address(0); DistributedTaskBuilder builder = des.createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); builder.timeout(100, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); expectException(ExecutionException.class, () -> future.get()); }
public void testBasicDistributedCallableWithNullKeys() throws Exception { Cache<Object, Object> c1 = getCache(); c1.put("key1", "value1"); c1.put("key2", "value2"); c1.put("key3", "value3"); c1.put("key4", "value4"); DistributedExecutorService des = createDES(getCache()); des.submit(new SimpleDistributedCallable(false)); }
public void testBasicTargetRemoteDistributedCallableWithException() throws Exception { Cache<Object, Object> cache1 = cache(0, cacheName()); Cache<Object, Object> cache2 = cache(1, cacheName()); // initiate task from cache1 and execute on same node DistributedExecutorService des = createDES(cache1); Address target = cache2.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder builder = des .createDistributedTaskBuilder(new ExceptionThrowingCallable()); Future<Integer> future = des.submit(target, builder.build()); expectException(ExecutionException.class, () -> future.get()); }
public void testBasicTargetDistributedCallableWithTimeout() throws Exception { Cache<Object, Object> cache1 = getCache(); // initiate task from cache1 and select cache2 as target DistributedExecutorService des = createDES(cache1); Address target = cache1.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder<Integer> builder = des.createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); builder.timeout(10, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); expectException(ExecutionException.class, TimeoutException.class, () -> future.get()); latchHolder.get().open(); }
public void testBasicTargetLocalDistributedCallableWithHighFutureAndLowTaskTimeout() throws Exception { Cache<Object, Object> cache1 = cache(0, cacheName()); // initiate task from cache1 and execute on same node DistributedExecutorService des = createDES(cache1); Address target = cache1.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder builder = des .createDistributedTaskBuilder(new SleepingSimpleCallable(latchHolder)); builder.timeout(100, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); expectException(TimeoutException.class, () -> future.get(10000, TimeUnit.MILLISECONDS)); latchHolder.get().open(); }