public void testShutdownNow() throws Exception { TestRtryCallable<String> tc = new TestRtryCallable<String>("X", 2, 3); schedPooled.schedule(tc, 1, TimeUnit.SECONDS); schedPooled.schedule(tc, 2, TimeUnit.SECONDS); List<Runnable> l = schedPooled.shutdownNow(); assertEquals(2, l.size()); Thread.sleep(100); assertTrue(schedPooled.isTerminated()); }
// Plain runnable with value (no special handling) public void testBasicRunnableWithValue() throws Exception { TestRunnable tr = new TestRunnable(); assertEquals(0, tr.runs); Future<String> f = schedInline.submit(tr, "X"); assertEquals("X", f.get()); assertEquals(1, tr.runs); }
// Plain callable (no special handling) public void testBasicCallable() throws Exception { TestCallable<String> tc = new TestCallable<String>("X"); assertEquals(0, tc.runs); Future<String> f = schedInline.submit(tc); assertEquals("X", f.get()); assertEquals(1, tc.runs); }
// Plain callable (no special handling) public void testBasicScheduledCallable() throws Exception { TestCallable<String> tc = new TestCallable<String>("X"); assertEquals(0, tc.runs); Future<String> f = schedInline.schedule(tc, 10, TimeUnit.MILLISECONDS); assertEquals("X", f.get()); assertEquals(1, tc.runs); }
// Plain runnable (no special handling) public void testBasicRunnable() { TestRunnable tr = new TestRunnable(); assertEquals(0, tr.runs); schedInline.execute(tr); while (tr.runs < 1) { Thread.yield(); } assertEquals(1, tr.runs); }
// Verify you can return null from your callable public void testRetryableCallableReturningNull() throws Exception { TestRtryCallable<Object> tc = new TestRtryCallable<Object>(null, 1, 1); assertEquals(0, tc.runs); assertEquals(0, tc.retries); Future<Object> f = schedPooled.submit(tc); assertNull(f.get()); assertFalse(tc.gaveUp); assertEquals(2, tc.runs); assertEquals(1, tc.retries); }
// Verify you can still return an exception from your callable public void testRetryableCallableReturningExc() throws Exception { ExecutionException e = new ExecutionException(new Exception()); TestRtryCallable<ExecutionException> tc = new TestRtryCallable<ExecutionException>(e, 0, 1); assertEquals(0, tc.runs); assertEquals(0, tc.retries); Future<ExecutionException> f = schedPooled.submit(tc); assertSame(e, f.get()); assertFalse(tc.gaveUp); assertEquals(1, tc.runs); assertEquals(0, tc.retries); }
public void testFixedDelayRunnable() throws Exception { TestRunnable r = new TestRunnable(); ScheduledFuture<?> f = schedPooled.scheduleWithFixedDelay(r, 10, 10, TimeUnit.MILLISECONDS); assertFalse(f.isDone()); assertEquals(0, r.runs); Thread.sleep(20); assertTrue(r.runs > 0); assertFalse(f.isCancelled()); f.cancel(true); assertTrue(f.isCancelled()); }
@SuppressWarnings("unchecked") // java 1.5 screwed up invokeAll's definition public void testInvokeAnyWithRetry() throws Exception { Collection<Callable<String>> callables = new ArrayList<Callable<String>>( Arrays.asList( new TestRtryCallable<String>("A", 4, 5), new TestRtryCallable<String>("B", 6, 5), new TestRtryCallable<String>("C", 3, 5))); String res = schedPooled.invokeAny(callables); assertEquals("Got " + res + ", expected C", "C", res); }
// A few retries and then success public void testRetryableCallable() throws Exception { TestRtryCallable<String> tc = new TestRtryCallable<String>("X", 2, 3); assertEquals(0, tc.runs); assertEquals(0, tc.retries); Future<String> f = schedPooled.submit(tc); assertEquals("X", f.get()); assertTrue(f.isDone()); assertFalse(f.isCancelled()); assertFalse(tc.gaveUp); assertEquals("X", tc.result); assertEquals(3, tc.runs); assertEquals(2, tc.retries); }
// A few retries and then success public void testCancellingRetryableCallable() throws Exception { TestRtryCallable<String> tc = new TestRtryCallable<String>("X", 2, 3); assertEquals(0, tc.runs); assertEquals(0, tc.retries); Future<String> f = schedPooled.submit(tc); f.cancel(true); try { Object o = f.get(); fail("expected cancellation, got " + o); } catch (CancellationException e) { // ok } }
@SuppressWarnings("unchecked") // java 1.5 screwed up invokeAll's definition public void testInvokeAnyWithRetryTimeout() throws Exception { Collection<Callable<String>> callables = new ArrayList<Callable<String>>( Arrays.asList( new TestRtryCallable<String>("A", 4, 3), new TestRtryCallable<String>("B", 1, 3), new TestRtryCallable<String>("C", 3, 5))); String res = schedPooled.invokeAny(callables, 10, TimeUnit.SECONDS); assertEquals("B", res); }
public void testInvokeAnyTimeout() throws Exception { // java 1.5 screwed up invokeAny's definition @SuppressWarnings("unchecked") Collection<Callable<String>> callables = new ArrayList<Callable<String>>( Arrays.asList( new TestCallable<String>("A"), new TestCallable<String>("B", 30), new TestCallable<String>("C", 30))); String res = schedPooled.invokeAny(callables, 10, TimeUnit.MILLISECONDS); assertEquals("A", res); }
@Override protected void tearDown() throws Exception { super.tearDown(); schedInline.shutdown(); assertTrue(schedInline.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS)); schedPooled.shutdown(); assertTrue(schedPooled.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS)); // Note: This is always true because the inline scheduler never says no assertTrue(schedInline.isShutdown()); assertTrue(schedPooled.isShutdown()); }
public void testInvokeAnyWithRetryTimeoutTimedOut() throws Exception { // java 1.5 screwed up invokeAny's definition @SuppressWarnings("unchecked") Collection<Callable<String>> callables = new ArrayList<Callable<String>>( Arrays.asList( new TestRtryCallable<String>("A", 5, 9, 1000), new TestRtryCallable<String>("B", 5, 9, 1000), new TestRtryCallable<String>("C", 5, 9, 1000))); try { String res = schedPooled.invokeAny(callables, 10, TimeUnit.MILLISECONDS); fail("Expected timeout, got " + res); } catch (TimeoutException e) { // OK } }
public void testInvokeAnyException() throws Exception { // java 1.5 screwed up invokeAny's definition @SuppressWarnings("unchecked") Collection<Callable<String>> callables = new ArrayList<Callable<String>>( Arrays.asList( new TestRtryCallable<String>("A", 4, 3), new TestRtryCallable<String>("B", 4, 3), new TestRtryCallable<String>("C", 4, 3))); try { String res = schedPooled.invokeAny(callables); fail("Expected exception, got " + res); } catch (ExecutionException e) { // OK } }
@SuppressWarnings("unchecked") // java 1.5 screwed up invokeAll's definition public void testInvokeAllWithRetry() throws Exception { Collection callables = Arrays.asList( new TestRtryCallable<String>("A", 2, 3), new TestRtryCallable<String>("B", 2, 3), new TestRtryCallable<String>("C", 2, 3)); List<String> expected = new ArrayList<String>(); expected.addAll(Arrays.asList("A", "B", "C")); List<String> got = new ArrayList<String>(); List<Future<String>> res = schedPooled.invokeAll(callables); for (Future<String> f : res) { got.add(f.get()); } assertEquals(expected, got); }
@SuppressWarnings("unchecked") // java 1.5 screwed up invokeAll's definition public void testInvokeAllTimeout() throws Exception { Collection callables = Arrays.asList( new TestCallable<String>("A"), new TestCallable<String>("B"), new TestCallable<String>("C")); Set<String> expected = new HashSet<String>(); expected.addAll(Arrays.asList("A", "B", "C")); Set<String> got = new HashSet<String>(); List<Future<String>> res = schedInline.invokeAll(callables, 10, TimeUnit.MILLISECONDS); for (Future<String> f : res) { got.add(f.get()); } assertEquals(expected, got); }
public void testInvokeAny() throws Exception { // java 1.5 screwed up invokeAny's definition @SuppressWarnings("unchecked") Collection c = Arrays.asList( new TestCallable<String>("A"), new TestCallable<String>("B"), new TestCallable<String>("C")); // java 1.5 screwed up invokeAny's definition @SuppressWarnings("unchecked") Collection<Callable<String>> callables = c; Set<String> expected = new HashSet<String>(); expected.addAll(Arrays.asList("A", "B", "C")); String res = schedInline.invokeAny(callables); assertTrue(expected.contains(res)); }
public void testInvokeAnyExceptionTimeout() throws Exception { // java 1.5 screwed up invokeAny's definition @SuppressWarnings("unchecked") Collection<Callable<String>> callables = new ArrayList<Callable<String>>(); for (int i = 0; i < 3; i++) { callables.add( new Callable<String>() { public String call() throws Exception { throw new Exception("Nope"); } }); } try { String res = schedPooled.invokeAny(callables, 10, TimeUnit.MILLISECONDS); fail("Expected exception, got " + res); } catch (ExecutionException e) { // OK } }
// A few retries and a failure public void testFailingRetryableCallable() throws Exception { TestRtryCallable<String> tc = new TestRtryCallable<String>("X", 4, 3); assertEquals(0, tc.runs); assertEquals(0, tc.retries); Future<String> f = schedPooled.submit(tc); try { String s = f.get(); fail("Expected failure, got " + s); } catch (ExecutionException e) { assertEquals("Too many failures", e.getMessage()); assertEquals(4, ((CompositeExecutorException) e).getExceptions().size()); StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); e.printStackTrace(pw); assertTrue("Hey, no also caused by", sw.toString().indexOf("Also caused by") > 0); assertSame(e, tc.result); } assertTrue(tc.gaveUp); assertEquals(4, tc.runs); assertEquals(3, tc.retries); }
@SuppressWarnings("unchecked") // java 1.5 screwed up invokeAll's definition public void testInvokeAllWithRetryTimeout() throws Exception { Collection callables = Arrays.asList( new TestRtryCallable<String>("A", 1, 9, 10), new TestRtryCallable<String>("B", 5, 9, 100), new TestRtryCallable<String>("C", 7, 9, 1000)); // Only one of these should finish. List<String> expected = new ArrayList<String>(); expected.addAll(Arrays.asList("A")); List<String> got = new ArrayList<String>(); List<Future<String>> res = schedPooled.invokeAll(callables, 20, TimeUnit.MILLISECONDS); for (Future<String> f : res) { if (f.isDone()) { got.add(f.get()); } } assertEquals(expected, got); }
public void testScheduledFutureSorting() throws Exception { TestRtryCallable<String> tc = new TestRtryCallable<String>("X", 2, 3); ScheduledFuture<String> f1 = schedPooled.schedule(tc, 10, TimeUnit.MILLISECONDS); ScheduledFuture<String> f2 = schedPooled.schedule(tc, 100, TimeUnit.MILLISECONDS); assertTrue(f1.compareTo(f2) < 0); }