diff options
Diffstat (limited to 'concurrent/src/test/java')
52 files changed, 18147 insertions, 9596 deletions
diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractExecutorServiceTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractExecutorServiceTest.java index b80fe64..a8db7ad 100644 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractExecutorServiceTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractExecutorServiceTest.java @@ -2,24 +2,25 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.math.BigInteger; import java.security.*; -public class AbstractExecutorServiceTest extends JSR166TestCase{ +public class AbstractExecutorServiceTest extends JSR166TestCase { public static Test suite() { return new TestSuite(AbstractExecutorServiceTest.class); } - /** + /** * A no-frills implementation of AbstractExecutorService, designed * to test the submit methods only. */ @@ -36,188 +37,106 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * execute(runnable) runs it to completion */ - public void testExecuteRunnable() { - try { - ExecutorService e = new DirectExecutorService(); - TrackedShortRunnable task = new TrackedShortRunnable(); - assertFalse(task.done); - Future<?> future = e.submit(task); - future.get(); - assertTrue(task.done); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); - } + public void testExecuteRunnable() throws Exception { + ExecutorService e = new DirectExecutorService(); + TrackedShortRunnable task = new TrackedShortRunnable(); + assertFalse(task.done); + Future<?> future = e.submit(task); + future.get(); + assertTrue(task.done); } /** * Completed submit(callable) returns result */ - public void testSubmitCallable() { - try { - ExecutorService e = new DirectExecutorService(); - Future<String> future = e.submit(new StringTask()); - String result = future.get(); - assertSame(TEST_STRING, result); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); - } + public void testSubmitCallable() throws Exception { + ExecutorService e = new DirectExecutorService(); + Future<String> future = e.submit(new StringTask()); + String result = future.get(); + assertSame(TEST_STRING, result); } /** * Completed submit(runnable) returns successfully */ - public void testSubmitRunnable() { - try { - ExecutorService e = new DirectExecutorService(); - Future<?> future = e.submit(new NoOpRunnable()); - future.get(); - assertTrue(future.isDone()); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); - } + public void testSubmitRunnable() throws Exception { + ExecutorService e = new DirectExecutorService(); + Future<?> future = e.submit(new NoOpRunnable()); + future.get(); + assertTrue(future.isDone()); } /** * Completed submit(runnable, result) returns result */ - public void testSubmitRunnable2() { - try { - ExecutorService e = new DirectExecutorService(); - Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING); - String result = future.get(); - assertSame(TEST_STRING, result); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); - } + public void testSubmitRunnable2() throws Exception { + ExecutorService e = new DirectExecutorService(); + Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING); + String result = future.get(); + assertSame(TEST_STRING, result); } /** - * A submitted privileged action to completion + * A submitted privileged action runs to completion */ - public void testSubmitPrivilegedAction() { - Policy savedPolicy = null; - try { - savedPolicy = Policy.getPolicy(); - AdjustablePolicy policy = new AdjustablePolicy(); - policy.addPermission(new RuntimePermission("getContextClassLoader")); - policy.addPermission(new RuntimePermission("setContextClassLoader")); - Policy.setPolicy(policy); - } catch(AccessControlException ok) { - return; - } - try { - ExecutorService e = new DirectExecutorService(); - Future future = e.submit(Executors.callable(new PrivilegedAction() { + public void testSubmitPrivilegedAction() throws Exception { + Runnable r = new CheckedRunnable() { + public void realRun() throws Exception { + ExecutorService e = new DirectExecutorService(); + Future future = e.submit(Executors.callable(new PrivilegedAction() { public Object run() { return TEST_STRING; }})); - Object result = future.get(); - assertSame(TEST_STRING, result); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); - } - finally { - try { - Policy.setPolicy(savedPolicy); - } catch(AccessControlException ok) { - return; - } - } + assertSame(TEST_STRING, future.get()); + }}; + + runWithPermissions(r, + new RuntimePermission("getClassLoader"), + new RuntimePermission("setContextClassLoader"), + new RuntimePermission("modifyThread")); } /** - * A submitted a privileged exception action runs to completion + * A submitted privileged exception action runs to completion */ - public void testSubmitPrivilegedExceptionAction() { - Policy savedPolicy = null; - try { - savedPolicy = Policy.getPolicy(); - AdjustablePolicy policy = new AdjustablePolicy(); - policy.addPermission(new RuntimePermission("getContextClassLoader")); - policy.addPermission(new RuntimePermission("setContextClassLoader")); - Policy.setPolicy(policy); - } catch(AccessControlException ok) { - return; - } - - try { - ExecutorService e = new DirectExecutorService(); - Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() { + public void testSubmitPrivilegedExceptionAction() throws Exception { + Runnable r = new CheckedRunnable() { + public void realRun() throws Exception { + ExecutorService e = new DirectExecutorService(); + Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() { public Object run() { return TEST_STRING; }})); - Object result = future.get(); - assertSame(TEST_STRING, result); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); - } - finally { - Policy.setPolicy(savedPolicy); - } + assertSame(TEST_STRING, future.get()); + }}; + + runWithPermissions(r); } /** * A submitted failed privileged exception action reports exception */ - public void testSubmitFailedPrivilegedExceptionAction() { - Policy savedPolicy = null; - try { - savedPolicy = Policy.getPolicy(); - AdjustablePolicy policy = new AdjustablePolicy(); - policy.addPermission(new RuntimePermission("getContextClassLoader")); - policy.addPermission(new RuntimePermission("setContextClassLoader")); - Policy.setPolicy(policy); - } catch(AccessControlException ok) { - return; - } - - - try { - ExecutorService e = new DirectExecutorService(); - Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() { + public void testSubmitFailedPrivilegedExceptionAction() throws Exception { + Runnable r = new CheckedRunnable() { + public void realRun() throws Exception { + ExecutorService e = new DirectExecutorService(); + Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() { public Object run() throws Exception { throw new IndexOutOfBoundsException(); }})); - Object result = future.get(); - shouldThrow(); - } - catch (ExecutionException success) { - } - catch (InterruptedException ex) { - unexpectedException(); - } - finally { - Policy.setPolicy(savedPolicy); - } + try { + future.get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof IndexOutOfBoundsException); + }}}; + + runWithPermissions(r); } /** @@ -226,15 +145,9 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ public void testExecuteNullRunnable() { try { ExecutorService e = new DirectExecutorService(); - TrackedShortRunnable task = null; - Future<?> future = e.submit(task); + e.submit((Runnable) null); shouldThrow(); - } - catch (NullPointerException success) { - } - catch (Exception ex) { - unexpectedException(); - } + } catch (NullPointerException success) {} } @@ -244,15 +157,9 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ public void testSubmitNullCallable() { try { ExecutorService e = new DirectExecutorService(); - StringTask t = null; - Future<String> future = e.submit(t); + e.submit((Callable) null); shouldThrow(); - } - catch (NullPointerException success) { - } - catch (Exception ex) { - unexpectedException(); - } + } catch (NullPointerException success) {} } /** @@ -260,15 +167,22 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ * executor is saturated. */ public void testExecute1() { - ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1)); + ThreadPoolExecutor p = + new ThreadPoolExecutor(1, 1, + 60, TimeUnit.SECONDS, + new ArrayBlockingQueue<Runnable>(1)); try { - - for(int i = 0; i < 5; ++i){ + for (int i = 0; i < 2; ++i) p.submit(new MediumRunnable()); + for (int i = 0; i < 2; ++i) { + try { + p.submit(new MediumRunnable()); + shouldThrow(); + } catch (RejectedExecutionException success) {} } - shouldThrow(); - } catch(RejectedExecutionException success){} - joinPool(p); + } finally { + joinPool(p); + } } /** @@ -276,14 +190,22 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ * if executor is saturated. */ public void testExecute2() { - ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1)); + ThreadPoolExecutor p = + new ThreadPoolExecutor(1, 1, + 60, TimeUnit.SECONDS, + new ArrayBlockingQueue<Runnable>(1)); try { - for(int i = 0; i < 5; ++i) { - p.submit(new SmallCallable()); + for (int i = 0; i < 2; ++i) + p.submit(new MediumRunnable()); + for (int i = 0; i < 2; ++i) { + try { + p.submit(new SmallCallable()); + shouldThrow(); + } catch (RejectedExecutionException success) {} } - shouldThrow(); - } catch(RejectedExecutionException e){} - joinPool(p); + } finally { + joinPool(p); + } } @@ -291,75 +213,43 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ * Blocking on submit(callable) throws InterruptedException if * caller interrupted. */ - public void testInterruptedSubmit() { + public void testInterruptedSubmit() throws InterruptedException { final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10)); - Thread t = new Thread(new Runnable() { - public void run() { - try { - p.submit(new Callable<Object>() { - public Object call() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - shouldThrow(); - } catch(InterruptedException e){ - } - return null; - } - }).get(); - } catch(InterruptedException success){ - } catch(Exception e) { - unexpectedException(); - } - - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws Exception { + p.submit(new CheckedCallable<Object>() { + public Object realCall() + throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); + return null; + }}).get(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); joinPool(p); } /** - * get of submitted callable throws Exception if callable + * get of submitted callable throws InterruptedException if callable * interrupted */ - public void testSubmitIE() { - final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10)); - - final Callable c = new Callable() { - public Object call() { - try { - p.submit(new SmallCallable()).get(); - shouldThrow(); - } catch(InterruptedException e){} - catch(RejectedExecutionException e2){} - catch(ExecutionException e3){} - return Boolean.TRUE; - } - }; - - - - Thread t = new Thread(new Runnable() { - public void run() { - try { - c.call(); - } catch(Exception e){} - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(InterruptedException e){ - unexpectedException(); - } - + public void testSubmitIE() throws InterruptedException { + final ThreadPoolExecutor p = + new ThreadPoolExecutor(1, 1, + 60, TimeUnit.SECONDS, + new ArrayBlockingQueue<Runnable>(10)); + + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws Exception { + p.submit(new SmallCallable()).get(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); joinPool(p); } @@ -367,26 +257,20 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ * get of submit(callable) throws ExecutionException if callable * throws exception */ - public void testSubmitEE() { - ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testSubmitEE() throws InterruptedException { + ThreadPoolExecutor p = + new ThreadPoolExecutor(1, 1, + 60, TimeUnit.SECONDS, + new ArrayBlockingQueue<Runnable>(10)); - try { - Callable c = new Callable() { - public Object call() { - int i = 5/0; - return Boolean.TRUE; - } - }; - - for(int i =0; i < 5; i++){ - p.submit(c).get(); - } + Callable c = new Callable() { + public Object call() { return 5/0; }}; + try { + p.submit(c).get(); shouldThrow(); - } - catch(ExecutionException success){ - } catch(Exception e) { - unexpectedException(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof ArithmeticException); } joinPool(p); } @@ -394,13 +278,13 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * invokeAny(null) throws NPE */ - public void testInvokeAny1() { + public void testInvokeAny1() + throws InterruptedException, ExecutionException { ExecutorService e = new DirectExecutorService(); try { e.invokeAny(null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -409,13 +293,13 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * invokeAny(empty collection) throws IAE */ - public void testInvokeAny2() { + public void testInvokeAny2() + throws InterruptedException, ExecutionException { ExecutorService e = new DirectExecutorService(); try { e.invokeAny(new ArrayList<Callable<String>>()); + shouldThrow(); } catch (IllegalArgumentException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -424,17 +308,16 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * invokeAny(c) throws NPE if c has null elements */ - public void testInvokeAny3() { + public void testInvokeAny3() throws Exception { ExecutorService e = new DirectExecutorService(); + List<Callable<Integer>> l = new ArrayList<Callable<Integer>>(); + l.add(new Callable<Integer>() { + public Integer call() { return 5/0; }}); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); e.invokeAny(l); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { joinPool(e); } @@ -443,15 +326,15 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * invokeAny(c) throws ExecutionException if no task in c completes */ - public void testInvokeAny4() { + public void testInvokeAny4() throws InterruptedException { ExecutorService e = new DirectExecutorService(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new NPETask()); e.invokeAny(l); - } catch(ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -460,17 +343,14 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * invokeAny(c) returns result of some task in c if at least one completes */ - public void testInvokeAny5() { + public void testInvokeAny5() throws Exception { ExecutorService e = new DirectExecutorService(); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); String result = e.invokeAny(l); assertSame(TEST_STRING, result); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -479,13 +359,12 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * invokeAll(null) throws NPE */ - public void testInvokeAll1() { + public void testInvokeAll1() throws InterruptedException { ExecutorService e = new DirectExecutorService(); try { e.invokeAll(null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -494,13 +373,11 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * invokeAll(empty collection) returns empty collection */ - public void testInvokeAll2() { + public void testInvokeAll2() throws InterruptedException { ExecutorService e = new DirectExecutorService(); try { List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>()); assertTrue(r.isEmpty()); - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -509,16 +386,15 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * invokeAll(c) throws NPE if c has null elements */ - public void testInvokeAll3() { + public void testInvokeAll3() throws InterruptedException { ExecutorService e = new DirectExecutorService(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); e.invokeAll(l); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -527,18 +403,19 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * get of returned element of invokeAll(c) throws exception on failed task */ - public void testInvokeAll4() { + public void testInvokeAll4() throws Exception { ExecutorService e = new DirectExecutorService(); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new NPETask()); - List<Future<String>> result = e.invokeAll(l); - assertEquals(1, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - it.next().get(); - } catch(ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + List<Future<String>> futures = e.invokeAll(l); + assertEquals(1, futures.size()); + try { + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } } finally { joinPool(e); } @@ -547,19 +424,16 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * invokeAll(c) returns results of all completed tasks in c */ - public void testInvokeAll5() { + public void testInvokeAll5() throws Exception { ExecutorService e = new DirectExecutorService(); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); - List<Future<String>> result = e.invokeAll(l); - assertEquals(2, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - assertSame(TEST_STRING, it.next().get()); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + List<Future<String>> futures = e.invokeAll(l); + assertEquals(2, futures.size()); + for (Future<String> future : futures) + assertSame(TEST_STRING, future.get()); } finally { joinPool(e); } @@ -569,13 +443,12 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAny(null) throws NPE */ - public void testTimedInvokeAny1() { + public void testTimedInvokeAny1() throws Exception { ExecutorService e = new DirectExecutorService(); try { - e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -584,15 +457,14 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAny(null time unit) throws NPE */ - public void testTimedInvokeAnyNullTimeUnit() { + public void testTimedInvokeAnyNullTimeUnit() throws Exception { ExecutorService e = new DirectExecutorService(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); e.invokeAny(l, MEDIUM_DELAY_MS, null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -601,13 +473,12 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAny(empty collection) throws IAE */ - public void testTimedInvokeAny2() { + public void testTimedInvokeAny2() throws Exception { ExecutorService e = new DirectExecutorService(); try { - e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (IllegalArgumentException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -616,17 +487,16 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAny(c) throws NPE if c has null elements */ - public void testTimedInvokeAny3() { + public void testTimedInvokeAny3() throws Exception { ExecutorService e = new DirectExecutorService(); + List<Callable<Integer>> l = new ArrayList<Callable<Integer>>(); + l.add(new Callable<Integer>() { + public Integer call() { return 5/0; }}); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); - e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { joinPool(e); } @@ -635,15 +505,15 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAny(c) throws ExecutionException if no task completes */ - public void testTimedInvokeAny4() { + public void testTimedInvokeAny4() throws Exception { ExecutorService e = new DirectExecutorService(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new NPETask()); - e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - } catch(ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -652,17 +522,14 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAny(c) returns result of some task in c */ - public void testTimedInvokeAny5() { + public void testTimedInvokeAny5() throws Exception { ExecutorService e = new DirectExecutorService(); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); - String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); assertSame(TEST_STRING, result); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -671,13 +538,12 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAll(null) throws NPE */ - public void testTimedInvokeAll1() { + public void testTimedInvokeAll1() throws InterruptedException { ExecutorService e = new DirectExecutorService(); try { - e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -686,15 +552,14 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAll(null time unit) throws NPE */ - public void testTimedInvokeAllNullTimeUnit() { + public void testTimedInvokeAllNullTimeUnit() throws InterruptedException { ExecutorService e = new DirectExecutorService(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); e.invokeAll(l, MEDIUM_DELAY_MS, null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -703,13 +568,11 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAll(empty collection) returns empty collection */ - public void testTimedInvokeAll2() { + public void testTimedInvokeAll2() throws InterruptedException { ExecutorService e = new DirectExecutorService(); try { - List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); assertTrue(r.isEmpty()); - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -718,16 +581,15 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAll(c) throws NPE if c has null elements */ - public void testTimedInvokeAll3() { + public void testTimedInvokeAll3() throws InterruptedException { ExecutorService e = new DirectExecutorService(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); - e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -736,18 +598,20 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * get of returned element of invokeAll(c) throws exception on failed task */ - public void testTimedInvokeAll4() { + public void testTimedInvokeAll4() throws Exception { ExecutorService e = new DirectExecutorService(); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new NPETask()); - List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - assertEquals(1, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - it.next().get(); - } catch(ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + List<Future<String>> futures = + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertEquals(1, futures.size()); + try { + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } } finally { joinPool(e); } @@ -756,19 +620,17 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAll(c) returns results of all completed tasks in c */ - public void testTimedInvokeAll5() { + public void testTimedInvokeAll5() throws Exception { ExecutorService e = new DirectExecutorService(); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); - List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - assertEquals(2, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - assertSame(TEST_STRING, it.next().get()); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + List<Future<String>> futures = + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertEquals(2, futures.size()); + for (Future<String> future : futures) + assertSame(TEST_STRING, future.get()); } finally { joinPool(e); } @@ -777,16 +639,17 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ /** * timed invokeAll cancels tasks not completed by timeout */ - public void testTimedInvokeAll6() { + public void testTimedInvokeAll6() throws InterruptedException { ExecutorService e = new DirectExecutorService(); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING)); l.add(new StringTask()); - List<Future<String>> result = e.invokeAll(l, SMALL_DELAY_MS, TimeUnit.MILLISECONDS); - assertEquals(3, result.size()); - Iterator<Future<String>> it = result.iterator(); + List<Future<String>> futures = + e.invokeAll(l, SMALL_DELAY_MS, MILLISECONDS); + assertEquals(3, futures.size()); + Iterator<Future<String>> it = futures.iterator(); Future<String> f1 = it.next(); Future<String> f2 = it.next(); Future<String> f3 = it.next(); @@ -795,8 +658,6 @@ public class AbstractExecutorServiceTest extends JSR166TestCase{ assertTrue(f2.isDone()); assertTrue(f3.isDone()); assertTrue(f3.isCancelled()); - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueueTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueueTest.java index 660fec9..9bb206b 100644 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueueTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueueTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; @@ -20,9 +20,9 @@ public class AbstractQueueTest extends JSR166TestCase { } static class Succeed extends AbstractQueue<Integer> { - public boolean offer(Integer x) { + public boolean offer(Integer x) { if (x == null) throw new NullPointerException(); - return true; + return true; } public Integer peek() { return one; } public Integer poll() { return one; } @@ -31,9 +31,9 @@ public class AbstractQueueTest extends JSR166TestCase { } static class Fail extends AbstractQueue<Integer> { - public boolean offer(Integer x) { + public boolean offer(Integer x) { if (x == null) throw new NullPointerException(); - return false; + return false; } public Integer peek() { return null; } public Integer poll() { return null; } @@ -57,8 +57,7 @@ public class AbstractQueueTest extends JSR166TestCase { try { q.add(one); shouldThrow(); - } catch (IllegalStateException success) { - } + } catch (IllegalStateException success) {} } /** @@ -69,8 +68,7 @@ public class AbstractQueueTest extends JSR166TestCase { try { q.add(null); shouldThrow(); - } catch (NullPointerException success) { - } + } catch (NullPointerException success) {} } /** @@ -89,8 +87,7 @@ public class AbstractQueueTest extends JSR166TestCase { try { q.remove(); shouldThrow(); - } catch (NoSuchElementException success) { - } + } catch (NoSuchElementException success) {} } @@ -110,8 +107,7 @@ public class AbstractQueueTest extends JSR166TestCase { try { q.element(); shouldThrow(); - } catch (NoSuchElementException success) { - } + } catch (NoSuchElementException success) {} } /** @@ -122,8 +118,7 @@ public class AbstractQueueTest extends JSR166TestCase { Succeed q = new Succeed(); q.addAll(null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -134,8 +129,7 @@ public class AbstractQueueTest extends JSR166TestCase { Succeed q = new Succeed(); q.addAll(q); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } @@ -148,8 +142,7 @@ public class AbstractQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll of a collection with any null elements throws NPE after @@ -163,8 +156,7 @@ public class AbstractQueueTest extends JSR166TestCase { ints[i] = new Integer(i); q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll throws ISE if an add fails @@ -177,8 +169,7 @@ public class AbstractQueueTest extends JSR166TestCase { ints[i] = new Integer(i); q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (IllegalStateException success) {} + } catch (IllegalStateException success) {} } } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueuedLongSynchronizerTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueuedLongSynchronizerTest.java new file mode 100644 index 0000000..43a4bd1 --- /dev/null +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueuedLongSynchronizerTest.java @@ -0,0 +1,1025 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. + */ + +package tests.api.java.util.concurrent; // android-added + +import junit.framework.*; +import java.util.*; +import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; +import java.util.concurrent.locks.*; +import java.io.*; + +public class AbstractQueuedLongSynchronizerTest extends JSR166TestCase { + public static Test suite() { + return new TestSuite(AbstractQueuedLongSynchronizerTest.class); + } + + /** + * A simple mutex class, adapted from the + * AbstractQueuedLongSynchronizer javadoc. Exclusive acquire tests + * exercise this as a sample user extension. Other + * methods/features of AbstractQueuedLongSynchronizerTest are tested + * via other test classes, including those for ReentrantLock, + * ReentrantReadWriteLock, and Semaphore + */ + static class Mutex extends AbstractQueuedLongSynchronizer { + // Use value > 32 bits for locked state + static final long LOCKED = 1 << 48; + public boolean isHeldExclusively() { + return getState() == LOCKED; + } + + public boolean tryAcquire(long acquires) { + return compareAndSetState(0, LOCKED); + } + + public boolean tryRelease(long releases) { + if (getState() == 0) throw new IllegalMonitorStateException(); + setState(0); + return true; + } + + public AbstractQueuedLongSynchronizer.ConditionObject newCondition() { return new AbstractQueuedLongSynchronizer.ConditionObject(); } + + } + + + /** + * A simple latch class, to test shared mode. + */ + static class BooleanLatch extends AbstractQueuedLongSynchronizer { + public boolean isSignalled() { return getState() != 0; } + + public long tryAcquireShared(long ignore) { + return isSignalled()? 1 : -1; + } + + public boolean tryReleaseShared(long ignore) { + setState(1 << 62); + return true; + } + } + + /** + * A runnable calling acquireInterruptibly that does not expect to + * be interrupted. + */ + class InterruptibleSyncRunnable extends CheckedRunnable { + final Mutex sync; + InterruptibleSyncRunnable(Mutex l) { sync = l; } + public void realRun() throws InterruptedException { + sync.acquireInterruptibly(1); + } + } + + + /** + * A runnable calling acquireInterruptibly that expects to be + * interrupted. + */ + class InterruptedSyncRunnable extends CheckedInterruptedRunnable { + final Mutex sync; + InterruptedSyncRunnable(Mutex l) { sync = l; } + public void realRun() throws InterruptedException { + sync.acquireInterruptibly(1); + } + } + + /** + * isHeldExclusively is false upon construction + */ + public void testIsHeldExclusively() { + Mutex rl = new Mutex(); + assertFalse(rl.isHeldExclusively()); + } + + /** + * acquiring released sync succeeds + */ + public void testAcquire() { + Mutex rl = new Mutex(); + rl.acquire(1); + assertTrue(rl.isHeldExclusively()); + rl.release(1); + assertFalse(rl.isHeldExclusively()); + } + + /** + * tryAcquire on an released sync succeeds + */ + public void testTryAcquire() { + Mutex rl = new Mutex(); + assertTrue(rl.tryAcquire(1)); + assertTrue(rl.isHeldExclusively()); + rl.release(1); + } + + /** + * hasQueuedThreads reports whether there are waiting threads + */ + public void testhasQueuedThreads() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertFalse(sync.hasQueuedThreads()); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThreads()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThreads()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThreads()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.hasQueuedThreads()); + t1.join(); + t2.join(); + } + + /** + * isQueued(null) throws NPE + */ + public void testIsQueuedNPE() { + final Mutex sync = new Mutex(); + try { + sync.isQueued(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * isQueued reports whether a thread is queued. + */ + public void testIsQueued() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertFalse(sync.isQueued(t1)); + assertFalse(sync.isQueued(t2)); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.isQueued(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.isQueued(t1)); + assertTrue(sync.isQueued(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.isQueued(t1)); + assertTrue(sync.isQueued(t2)); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.isQueued(t1)); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.isQueued(t2)); + t1.join(); + t2.join(); + } + + /** + * getFirstQueuedThread returns first waiting thread or null if none + */ + public void testGetFirstQueuedThread() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertNull(sync.getFirstQueuedThread()); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(t1, sync.getFirstQueuedThread()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(t1, sync.getFirstQueuedThread()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(t2, sync.getFirstQueuedThread()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertNull(sync.getFirstQueuedThread()); + t1.join(); + t2.join(); + } + + + /** + * hasContended reports false if no thread has ever blocked, else true + */ + public void testHasContended() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertFalse(sync.hasContended()); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + t1.join(); + t2.join(); + } + + /** + * getQueuedThreads includes waiting threads + */ + public void testGetQueuedThreads() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertTrue(sync.getQueuedThreads().isEmpty()); + sync.acquire(1); + assertTrue(sync.getQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getQueuedThreads().contains(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getQueuedThreads().contains(t1)); + assertTrue(sync.getQueuedThreads().contains(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.getQueuedThreads().contains(t1)); + assertTrue(sync.getQueuedThreads().contains(t2)); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getQueuedThreads().isEmpty()); + t1.join(); + t2.join(); + } + + /** + * getExclusiveQueuedThreads includes waiting threads + */ + public void testGetExclusiveQueuedThreads() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); + sync.acquire(1); + assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getExclusiveQueuedThreads().contains(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getExclusiveQueuedThreads().contains(t1)); + assertTrue(sync.getExclusiveQueuedThreads().contains(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.getExclusiveQueuedThreads().contains(t1)); + assertTrue(sync.getExclusiveQueuedThreads().contains(t2)); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); + t1.join(); + t2.join(); + } + + /** + * getSharedQueuedThreads does not include exclusively waiting threads + */ + public void testGetSharedQueuedThreads() throws InterruptedException { + final Mutex sync = new Mutex(); + Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); + Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + sync.acquire(1); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t1.join(); + t2.join(); + } + + /** + * tryAcquireNanos is interruptible. + */ + public void testInterruptedException2() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquire(1); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + sync.tryAcquireNanos(1, MILLISECONDS.toNanos(MEDIUM_DELAY_MS)); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + } + + + /** + * TryAcquire on exclusively held sync fails + */ + public void testTryAcquireWhenSynced() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquire(1); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + threadAssertFalse(sync.tryAcquire(1)); + }}); + + t.start(); + t.join(); + sync.release(1); + } + + /** + * tryAcquireNanos on an exclusively held sync times out + */ + public void testAcquireNanos_Timeout() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquire(1); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + long nanos = MILLISECONDS.toNanos(SHORT_DELAY_MS); + assertFalse(sync.tryAcquireNanos(1, nanos)); + }}); + + t.start(); + t.join(); + sync.release(1); + } + + + /** + * getState is true when acquired and false when not + */ + public void testGetState() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquire(1); + assertTrue(sync.isHeldExclusively()); + sync.release(1); + assertFalse(sync.isHeldExclusively()); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + Thread.sleep(SMALL_DELAY_MS); + sync.release(1); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.isHeldExclusively()); + t.join(); + assertFalse(sync.isHeldExclusively()); + } + + + /** + * acquireInterruptibly is interruptible. + */ + public void testAcquireInterruptibly1() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquire(1); + Thread t = new Thread(new InterruptedSyncRunnable(sync)); + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + sync.release(1); + t.join(); + } + + /** + * acquireInterruptibly succeeds when released, else is interruptible + */ + public void testAcquireInterruptibly2() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquireInterruptibly(1); + Thread t = new Thread(new InterruptedSyncRunnable(sync)); + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + assertTrue(sync.isHeldExclusively()); + t.join(); + } + + /** + * owns is true for a condition created by sync else false + */ + public void testOwns() { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + final Mutex sync2 = new Mutex(); + assertTrue(sync.owns(c)); + assertFalse(sync2.owns(c)); + } + + /** + * Calling await without holding sync throws IllegalMonitorStateException + */ + public void testAwait_IllegalMonitor() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + try { + c.await(); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + } + + /** + * Calling signal without holding sync throws IllegalMonitorStateException + */ + public void testSignal_IllegalMonitor() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + try { + c.signal(); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + } + + /** + * awaitNanos without a signal times out + */ + public void testAwaitNanos_Timeout() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + sync.acquire(1); + long t = c.awaitNanos(100); + assertTrue(t <= 0); + sync.release(1); + } + + /** + * Timed await without a signal times out + */ + public void testAwait_Timeout() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + sync.acquire(1); + assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS)); + sync.release(1); + } + + /** + * awaitUntil without a signal times out + */ + public void testAwaitUntil_Timeout() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + sync.acquire(1); + java.util.Date d = new java.util.Date(); + assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10))); + sync.release(1); + } + + /** + * await returns when signalled + */ + public void testAwait() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + c.await(); + sync.release(1); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + c.signal(); + sync.release(1); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); + } + + + + /** + * hasWaiters throws NPE if null + */ + public void testHasWaitersNPE() { + final Mutex sync = new Mutex(); + try { + sync.hasWaiters(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * getWaitQueueLength throws NPE if null + */ + public void testGetWaitQueueLengthNPE() { + final Mutex sync = new Mutex(); + try { + sync.getWaitQueueLength(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + /** + * getWaitingThreads throws NPE if null + */ + public void testGetWaitingThreadsNPE() { + final Mutex sync = new Mutex(); + try { + sync.getWaitingThreads(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + /** + * hasWaiters throws IAE if not owned + */ + public void testHasWaitersIAE() { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + final Mutex sync2 = new Mutex(); + try { + sync2.hasWaiters(c); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * hasWaiters throws IMSE if not synced + */ + public void testHasWaitersIMSE() { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + try { + sync.hasWaiters(c); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + } + + + /** + * getWaitQueueLength throws IAE if not owned + */ + public void testGetWaitQueueLengthIAE() { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + final Mutex sync2 = new Mutex(); + try { + sync2.getWaitQueueLength(c); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * getWaitQueueLength throws IMSE if not synced + */ + public void testGetWaitQueueLengthIMSE() { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + try { + sync.getWaitQueueLength(c); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + } + + + /** + * getWaitingThreads throws IAE if not owned + */ + public void testGetWaitingThreadsIAE() { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + final Mutex sync2 = new Mutex(); + try { + sync2.getWaitingThreads(c); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * getWaitingThreads throws IMSE if not synced + */ + public void testGetWaitingThreadsIMSE() { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + try { + sync.getWaitingThreads(c); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + } + + + + /** + * hasWaiters returns true when a thread is waiting, else false + */ + public void testHasWaiters() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + threadAssertFalse(sync.hasWaiters(c)); + threadAssertEquals(0, sync.getWaitQueueLength(c)); + c.await(); + sync.release(1); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertTrue(sync.hasWaiters(c)); + assertEquals(1, sync.getWaitQueueLength(c)); + c.signal(); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertFalse(sync.hasWaiters(c)); + assertEquals(0, sync.getWaitQueueLength(c)); + sync.release(1); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); + } + + /** + * getWaitQueueLength returns number of waiting threads + */ + public void testGetWaitQueueLength() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + threadAssertFalse(sync.hasWaiters(c)); + threadAssertEquals(0, sync.getWaitQueueLength(c)); + c.await(); + sync.release(1); + }}); + + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + threadAssertTrue(sync.hasWaiters(c)); + threadAssertEquals(1, sync.getWaitQueueLength(c)); + c.await(); + sync.release(1); + }}); + + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertTrue(sync.hasWaiters(c)); + assertEquals(2, sync.getWaitQueueLength(c)); + c.signalAll(); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertFalse(sync.hasWaiters(c)); + assertEquals(0, sync.getWaitQueueLength(c)); + sync.release(1); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); + } + + /** + * getWaitingThreads returns only and all waiting threads + */ + public void testGetWaitingThreads() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + threadAssertTrue(sync.getWaitingThreads(c).isEmpty()); + c.await(); + sync.release(1); + }}); + + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + threadAssertFalse(sync.getWaitingThreads(c).isEmpty()); + c.await(); + sync.release(1); + }}); + + sync.acquire(1); + assertTrue(sync.getWaitingThreads(c).isEmpty()); + sync.release(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertTrue(sync.hasWaiters(c)); + assertTrue(sync.getWaitingThreads(c).contains(t1)); + assertTrue(sync.getWaitingThreads(c).contains(t2)); + c.signalAll(); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertFalse(sync.hasWaiters(c)); + assertTrue(sync.getWaitingThreads(c).isEmpty()); + sync.release(1); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); + } + + + + /** + * awaitUninterruptibly doesn't abort on interrupt + */ + public void testAwaitUninterruptibly() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + sync.acquire(1); + c.awaitUninterruptibly(); + sync.release(1); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + sync.acquire(1); + c.signal(); + sync.release(1); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); + } + + /** + * await is interruptible + */ + public void testAwait_Interrupt() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + c.await(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); + } + + /** + * awaitNanos is interruptible + */ + public void testAwaitNanos_Interrupt() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); + } + + /** + * awaitUntil is interruptible + */ + public void testAwaitUntil_Interrupt() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + java.util.Date d = new java.util.Date(); + c.awaitUntil(new java.util.Date(d.getTime() + 10000)); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); + } + + /** + * signalAll wakes up all threads + */ + public void testSignalAll() throws InterruptedException { + final Mutex sync = new Mutex(); + final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition(); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + c.await(); + sync.release(1); + }}); + + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + c.await(); + sync.release(1); + }}); + + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + c.signalAll(); + sync.release(1); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); + } + + + /** + * toString indicates current state + */ + public void testToString() { + Mutex sync = new Mutex(); + String us = sync.toString(); + assertTrue(us.indexOf("State = 0") >= 0); + sync.acquire(1); + String ls = sync.toString(); + assertTrue(ls.indexOf("State = " + Mutex.LOCKED) >= 0); + } + + /** + * A serialized AQS deserializes with current state + */ + public void testSerialization() throws Exception { + Mutex l = new Mutex(); + l.acquire(1); + assertTrue(l.isHeldExclusively()); + + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + Mutex r = (Mutex) in.readObject(); + assertTrue(r.isHeldExclusively()); + } + + + /** + * tryReleaseShared setting state changes getState + */ + public void testGetStateWithReleaseShared() { + final BooleanLatch l = new BooleanLatch(); + assertFalse(l.isSignalled()); + l.releaseShared(0); + assertTrue(l.isSignalled()); + } + + /** + * releaseShared has no effect when already signalled + */ + public void testReleaseShared() { + final BooleanLatch l = new BooleanLatch(); + assertFalse(l.isSignalled()); + l.releaseShared(0); + assertTrue(l.isSignalled()); + l.releaseShared(0); + assertTrue(l.isSignalled()); + } + + /** + * acquireSharedInterruptibly returns after release, but not before + */ + public void testAcquireSharedInterruptibly() throws InterruptedException { + final BooleanLatch l = new BooleanLatch(); + + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + threadAssertFalse(l.isSignalled()); + l.acquireSharedInterruptibly(0); + threadAssertTrue(l.isSignalled()); + }}); + + t.start(); + assertFalse(l.isSignalled()); + Thread.sleep(SHORT_DELAY_MS); + l.releaseShared(0); + assertTrue(l.isSignalled()); + t.join(); + } + + + /** + * acquireSharedTimed returns after release + */ + public void testAsquireSharedTimed() throws InterruptedException { + final BooleanLatch l = new BooleanLatch(); + + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(l.isSignalled()); + long nanos = MILLISECONDS.toNanos(MEDIUM_DELAY_MS); + assertTrue(l.tryAcquireSharedNanos(0, nanos)); + assertTrue(l.isSignalled()); + }}); + + t.start(); + assertFalse(l.isSignalled()); + Thread.sleep(SHORT_DELAY_MS); + l.releaseShared(0); + assertTrue(l.isSignalled()); + t.join(); + } + + /** + * acquireSharedInterruptibly throws IE if interrupted before released + */ + public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException { + final BooleanLatch l = new BooleanLatch(); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + threadAssertFalse(l.isSignalled()); + l.acquireSharedInterruptibly(0); + }}); + + t.start(); + assertFalse(l.isSignalled()); + t.interrupt(); + t.join(); + } + + /** + * acquireSharedTimed throws IE if interrupted before released + */ + public void testAcquireSharedNanos_InterruptedException() throws InterruptedException { + final BooleanLatch l = new BooleanLatch(); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(l.isSignalled()); + long nanos = MILLISECONDS.toNanos(SMALL_DELAY_MS); + l.tryAcquireSharedNanos(0, nanos); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(l.isSignalled()); + t.interrupt(); + t.join(); + } + + /** + * acquireSharedTimed times out if not released before timeout + */ + public void testAcquireSharedNanos_Timeout() throws InterruptedException { + final BooleanLatch l = new BooleanLatch(); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(l.isSignalled()); + long nanos = MILLISECONDS.toNanos(SMALL_DELAY_MS); + assertFalse(l.tryAcquireSharedNanos(0, nanos)); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(l.isSignalled()); + t.join(); + } + +} diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueuedSynchronizerTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueuedSynchronizerTest.java index e2cfe92..a5b6554 100644 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueuedSynchronizerTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueuedSynchronizerTest.java @@ -2,8 +2,8 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ package tests.api.java.util.concurrent; @@ -11,6 +11,7 @@ package tests.api.java.util.concurrent; import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.util.concurrent.locks.*; import java.io.*; @@ -29,33 +30,33 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { */ static class Mutex extends AbstractQueuedSynchronizer { public boolean isHeldExclusively() { return getState() == 1; } - + public boolean tryAcquire(int acquires) { - assertTrue(acquires == 1); + assertTrue(acquires == 1); return compareAndSetState(0, 1); } - + public boolean tryRelease(int releases) { if (getState() == 0) throw new IllegalMonitorStateException(); setState(0); return true; } - + public AbstractQueuedSynchronizer.ConditionObject newCondition() { return new AbstractQueuedSynchronizer.ConditionObject(); } } - + /** * A simple latch class, to test shared mode. */ - static class BooleanLatch extends AbstractQueuedSynchronizer { + static class BooleanLatch extends AbstractQueuedSynchronizer { public boolean isSignalled() { return getState() != 0; } public int tryAcquireShared(int ignore) { return isSignalled()? 1 : -1; } - + public boolean tryReleaseShared(int ignore) { setState(1); return true; @@ -63,46 +64,42 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { } /** - * A runnable calling acquireInterruptibly + * A runnable calling acquireInterruptibly that does not expect to + * be interrupted. */ - class InterruptibleSyncRunnable implements Runnable { + class InterruptibleSyncRunnable extends CheckedRunnable { final Mutex sync; InterruptibleSyncRunnable(Mutex l) { sync = l; } - public void run() { - try { - sync.acquireInterruptibly(1); - } catch(InterruptedException success){} + public void realRun() throws InterruptedException { + sync.acquireInterruptibly(1); } } /** * A runnable calling acquireInterruptibly that expects to be - * interrupted + * interrupted. */ - class InterruptedSyncRunnable implements Runnable { + class InterruptedSyncRunnable extends CheckedInterruptedRunnable { final Mutex sync; InterruptedSyncRunnable(Mutex l) { sync = l; } - public void run() { - try { - sync.acquireInterruptibly(1); - threadShouldThrow(); - } catch(InterruptedException success){} + public void realRun() throws InterruptedException { + sync.acquireInterruptibly(1); } } /** * isHeldExclusively is false upon construction */ - public void testIsHeldExclusively() { + public void testIsHeldExclusively() { Mutex rl = new Mutex(); assertFalse(rl.isHeldExclusively()); } - + /** * acquiring released sync succeeds */ - public void testAcquire() { + public void testAcquire() { Mutex rl = new Mutex(); rl.acquire(1); assertTrue(rl.isHeldExclusively()); @@ -113,7 +110,7 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { /** * tryAcquire on an released sync succeeds */ - public void testTryAcquire() { + public void testTryAcquire() { Mutex rl = new Mutex(); assertTrue(rl.tryAcquire(1)); assertTrue(rl.isHeldExclusively()); @@ -123,378 +120,314 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { /** * hasQueuedThreads reports whether there are waiting threads */ - public void testhasQueuedThreads() { + public void testhasQueuedThreads() throws InterruptedException { final Mutex sync = new Mutex(); Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); - try { - assertFalse(sync.hasQueuedThreads()); - sync.acquire(1); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasQueuedThreads()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasQueuedThreads()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasQueuedThreads()); - sync.release(1); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.hasQueuedThreads()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + assertFalse(sync.hasQueuedThreads()); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThreads()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThreads()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThreads()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.hasQueuedThreads()); + t1.join(); + t2.join(); + } /** * isQueued(null) throws NPE */ - public void testIsQueuedNPE() { + public void testIsQueuedNPE() { final Mutex sync = new Mutex(); try { sync.isQueued(null); shouldThrow(); - } catch (NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * isQueued reports whether a thread is queued. */ - public void testIsQueued() { + public void testIsQueued() throws InterruptedException { final Mutex sync = new Mutex(); Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); - try { - assertFalse(sync.isQueued(t1)); - assertFalse(sync.isQueued(t2)); - sync.acquire(1); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.isQueued(t1)); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.isQueued(t1)); - assertTrue(sync.isQueued(t2)); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.isQueued(t1)); - assertTrue(sync.isQueued(t2)); - sync.release(1); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.isQueued(t1)); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.isQueued(t2)); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + assertFalse(sync.isQueued(t1)); + assertFalse(sync.isQueued(t2)); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.isQueued(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.isQueued(t1)); + assertTrue(sync.isQueued(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.isQueued(t1)); + assertTrue(sync.isQueued(t2)); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.isQueued(t1)); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.isQueued(t2)); + t1.join(); + t2.join(); + } /** * getFirstQueuedThread returns first waiting thread or null if none */ - public void testGetFirstQueuedThread() { + public void testGetFirstQueuedThread() throws InterruptedException { final Mutex sync = new Mutex(); Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); - try { - assertNull(sync.getFirstQueuedThread()); - sync.acquire(1); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(t1, sync.getFirstQueuedThread()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(t1, sync.getFirstQueuedThread()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(t2, sync.getFirstQueuedThread()); - sync.release(1); - Thread.sleep(SHORT_DELAY_MS); - assertNull(sync.getFirstQueuedThread()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + assertNull(sync.getFirstQueuedThread()); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(t1, sync.getFirstQueuedThread()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(t1, sync.getFirstQueuedThread()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(t2, sync.getFirstQueuedThread()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertNull(sync.getFirstQueuedThread()); + t1.join(); + t2.join(); + } /** * hasContended reports false if no thread has ever blocked, else true */ - public void testHasContended() { + public void testHasContended() throws InterruptedException { final Mutex sync = new Mutex(); Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); - try { - assertFalse(sync.hasContended()); - sync.acquire(1); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasContended()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasContended()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasContended()); - sync.release(1); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasContended()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + assertFalse(sync.hasContended()); + sync.acquire(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasContended()); + t1.join(); + t2.join(); + } /** * getQueuedThreads includes waiting threads */ - public void testGetQueuedThreads() { + public void testGetQueuedThreads() throws InterruptedException { final Mutex sync = new Mutex(); Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); - try { - assertTrue(sync.getQueuedThreads().isEmpty()); - sync.acquire(1); - assertTrue(sync.getQueuedThreads().isEmpty()); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.getQueuedThreads().contains(t1)); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.getQueuedThreads().contains(t1)); - assertTrue(sync.getQueuedThreads().contains(t2)); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.getQueuedThreads().contains(t1)); - assertTrue(sync.getQueuedThreads().contains(t2)); - sync.release(1); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.getQueuedThreads().isEmpty()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + assertTrue(sync.getQueuedThreads().isEmpty()); + sync.acquire(1); + assertTrue(sync.getQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getQueuedThreads().contains(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getQueuedThreads().contains(t1)); + assertTrue(sync.getQueuedThreads().contains(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.getQueuedThreads().contains(t1)); + assertTrue(sync.getQueuedThreads().contains(t2)); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getQueuedThreads().isEmpty()); + t1.join(); + t2.join(); + } /** * getExclusiveQueuedThreads includes waiting threads */ - public void testGetExclusiveQueuedThreads() { + public void testGetExclusiveQueuedThreads() throws InterruptedException { final Mutex sync = new Mutex(); Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); - try { - assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); - sync.acquire(1); - assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.getExclusiveQueuedThreads().contains(t1)); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.getExclusiveQueuedThreads().contains(t1)); - assertTrue(sync.getExclusiveQueuedThreads().contains(t2)); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.getExclusiveQueuedThreads().contains(t1)); - assertTrue(sync.getExclusiveQueuedThreads().contains(t2)); - sync.release(1); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); + sync.acquire(1); + assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getExclusiveQueuedThreads().contains(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getExclusiveQueuedThreads().contains(t1)); + assertTrue(sync.getExclusiveQueuedThreads().contains(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.getExclusiveQueuedThreads().contains(t1)); + assertTrue(sync.getExclusiveQueuedThreads().contains(t2)); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); + t1.join(); + t2.join(); + } /** * getSharedQueuedThreads does not include exclusively waiting threads */ - public void testGetSharedQueuedThreads() { + public void testGetSharedQueuedThreads() throws InterruptedException { final Mutex sync = new Mutex(); Thread t1 = new Thread(new InterruptedSyncRunnable(sync)); Thread t2 = new Thread(new InterruptibleSyncRunnable(sync)); - try { - assertTrue(sync.getSharedQueuedThreads().isEmpty()); - sync.acquire(1); - assertTrue(sync.getSharedQueuedThreads().isEmpty()); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.getSharedQueuedThreads().isEmpty()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.getSharedQueuedThreads().isEmpty()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.getSharedQueuedThreads().isEmpty()); - sync.release(1); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.getSharedQueuedThreads().isEmpty()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + sync.acquire(1); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.getSharedQueuedThreads().isEmpty()); + t1.join(); + t2.join(); + } /** * tryAcquireNanos is interruptible. */ - public void testInterruptedException2() { + public void testInterruptedException2() throws InterruptedException { final Mutex sync = new Mutex(); sync.acquire(1); - Thread t = new Thread(new Runnable() { - public void run() { - try { - sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000); - threadShouldThrow(); - } catch(InterruptedException success){} - } - }); - try { - t.start(); - t.interrupt(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + sync.tryAcquireNanos(1, MILLISECONDS.toNanos(MEDIUM_DELAY_MS)); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * TryAcquire on exclusively held sync fails */ - public void testTryAcquireWhenSynced() { + public void testTryAcquireWhenSynced() throws InterruptedException { final Mutex sync = new Mutex(); sync.acquire(1); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertFalse(sync.tryAcquire(1)); - } - }); - try { - t.start(); - t.join(); - sync.release(1); - } catch(Exception e){ - unexpectedException(); - } - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + threadAssertFalse(sync.tryAcquire(1)); + }}); + + t.start(); + t.join(); + sync.release(1); + } /** * tryAcquireNanos on an exclusively held sync times out */ - public void testAcquireNanos_Timeout() { + public void testAcquireNanos_Timeout() throws InterruptedException { final Mutex sync = new Mutex(); sync.acquire(1); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertFalse(sync.tryAcquireNanos(1, 1000 * 1000)); - } catch (Exception ex) { - threadUnexpectedException(); - } - } - }); - try { - t.start(); - t.join(); - sync.release(1); - } catch(Exception e){ - unexpectedException(); - } - } - - + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + long nanos = MILLISECONDS.toNanos(SHORT_DELAY_MS); + assertFalse(sync.tryAcquireNanos(1, nanos)); + }}); + + t.start(); + t.join(); + sync.release(1); + } + + /** * getState is true when acquired and false when not */ - public void testGetState() { + public void testGetState() throws InterruptedException { final Mutex sync = new Mutex(); sync.acquire(1); assertTrue(sync.isHeldExclusively()); sync.release(1); assertFalse(sync.isHeldExclusively()); - Thread t = new Thread(new Runnable() { - public void run() { - sync.acquire(1); - try { - Thread.sleep(SMALL_DELAY_MS); - } - catch(Exception e) { - threadUnexpectedException(); - } - sync.release(1); - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.isHeldExclusively()); - t.join(); - assertFalse(sync.isHeldExclusively()); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + Thread.sleep(SMALL_DELAY_MS); + sync.release(1); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.isHeldExclusively()); + t.join(); + assertFalse(sync.isHeldExclusively()); } /** * acquireInterruptibly is interruptible. */ - public void testAcquireInterruptibly1() { + public void testAcquireInterruptibly1() throws InterruptedException { final Mutex sync = new Mutex(); sync.acquire(1); Thread t = new Thread(new InterruptedSyncRunnable(sync)); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - sync.release(1); - t.join(); - } catch(Exception e){ - unexpectedException(); - } - } + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + sync.release(1); + t.join(); + } /** * acquireInterruptibly succeeds when released, else is interruptible */ - public void testAcquireInterruptibly2() { - final Mutex sync = new Mutex(); - try { - sync.acquireInterruptibly(1); - } catch(Exception e) { - unexpectedException(); - } + public void testAcquireInterruptibly2() throws InterruptedException { + final Mutex sync = new Mutex(); + sync.acquireInterruptibly(1); Thread t = new Thread(new InterruptedSyncRunnable(sync)); - try { - t.start(); - t.interrupt(); - assertTrue(sync.isHeldExclusively()); - t.join(); - } catch(Exception e){ - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + assertTrue(sync.isHeldExclusively()); + t.join(); } /** * owns is true for a condition created by sync else false */ public void testOwns() { - final Mutex sync = new Mutex(); + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); final Mutex sync2 = new Mutex(); assertTrue(sync.owns(c)); @@ -504,118 +437,82 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { /** * Calling await without holding sync throws IllegalMonitorStateException */ - public void testAwait_IllegalMonitor() { - final Mutex sync = new Mutex(); + public void testAwait_IllegalMonitor() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); try { c.await(); shouldThrow(); - } - catch (IllegalMonitorStateException success) { - } - catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } /** * Calling signal without holding sync throws IllegalMonitorStateException */ public void testSignal_IllegalMonitor() { - final Mutex sync = new Mutex(); + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); try { c.signal(); shouldThrow(); - } - catch (IllegalMonitorStateException success) { - } - catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } /** * awaitNanos without a signal times out */ - public void testAwaitNanos_Timeout() { - final Mutex sync = new Mutex(); + public void testAwaitNanos_Timeout() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - try { - sync.acquire(1); - long t = c.awaitNanos(100); - assertTrue(t <= 0); - sync.release(1); - } - catch (Exception ex) { - unexpectedException(); - } + sync.acquire(1); + long t = c.awaitNanos(100); + assertTrue(t <= 0); + sync.release(1); } /** * Timed await without a signal times out */ - public void testAwait_Timeout() { - final Mutex sync = new Mutex(); + public void testAwait_Timeout() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - try { - sync.acquire(1); - assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - sync.release(1); - } - catch (Exception ex) { - unexpectedException(); - } + sync.acquire(1); + assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS)); + sync.release(1); } /** * awaitUntil without a signal times out */ - public void testAwaitUntil_Timeout() { - final Mutex sync = new Mutex(); + public void testAwaitUntil_Timeout() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - try { - sync.acquire(1); - java.util.Date d = new java.util.Date(); - assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10))); - sync.release(1); - } - catch (Exception ex) { - unexpectedException(); - } + sync.acquire(1); + java.util.Date d = new java.util.Date(); + assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10))); + sync.release(1); } /** * await returns when signalled */ - public void testAwait() { - final Mutex sync = new Mutex(); + public void testAwait() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - sync.acquire(1); - c.await(); - sync.release(1); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + c.await(); + sync.release(1); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - sync.acquire(1); - c.signal(); - sync.release(1); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + c.signal(); + sync.release(1); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } @@ -628,10 +525,7 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { try { sync.hasWaiters(null); shouldThrow(); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (NullPointerException success) {} } /** @@ -642,10 +536,7 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { try { sync.getWaitQueueLength(null); shouldThrow(); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (NullPointerException success) {} } @@ -657,10 +548,7 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { try { sync.getWaitingThreads(null); shouldThrow(); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (NullPointerException success) {} } @@ -669,15 +557,12 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { */ public void testHasWaitersIAE() { final Mutex sync = new Mutex(); - final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); final Mutex sync2 = new Mutex(); try { sync2.hasWaiters(c); shouldThrow(); - } catch (IllegalArgumentException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalArgumentException success) {} } /** @@ -685,14 +570,11 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { */ public void testHasWaitersIMSE() { final Mutex sync = new Mutex(); - final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); try { sync.hasWaiters(c); shouldThrow(); - } catch (IllegalMonitorStateException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } @@ -701,15 +583,12 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { */ public void testGetWaitQueueLengthIAE() { final Mutex sync = new Mutex(); - final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); final Mutex sync2 = new Mutex(); try { sync2.getWaitQueueLength(c); shouldThrow(); - } catch (IllegalArgumentException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalArgumentException success) {} } /** @@ -717,14 +596,11 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { */ public void testGetWaitQueueLengthIMSE() { final Mutex sync = new Mutex(); - final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); try { sync.getWaitQueueLength(c); shouldThrow(); - } catch (IllegalMonitorStateException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } @@ -732,31 +608,25 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { * getWaitingThreads throws IAE if not owned */ public void testGetWaitingThreadsIAE() { - final Mutex sync = new Mutex(); - final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); - final Mutex sync2 = new Mutex(); + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); + final Mutex sync2 = new Mutex(); try { sync2.getWaitingThreads(c); shouldThrow(); - } catch (IllegalArgumentException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalArgumentException success) {} } /** * getWaitingThreads throws IMSE if not synced */ public void testGetWaitingThreadsIMSE() { - final Mutex sync = new Mutex(); - final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); + final Mutex sync = new Mutex(); + final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); try { sync.getWaitingThreads(c); shouldThrow(); - } catch (IllegalMonitorStateException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } @@ -764,167 +634,122 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { /** * hasWaiters returns true when a thread is waiting, else false */ - public void testHasWaiters() { - final Mutex sync = new Mutex(); + public void testHasWaiters() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - sync.acquire(1); - threadAssertFalse(sync.hasWaiters(c)); - threadAssertEquals(0, sync.getWaitQueueLength(c)); - c.await(); - sync.release(1); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + threadAssertFalse(sync.hasWaiters(c)); + threadAssertEquals(0, sync.getWaitQueueLength(c)); + c.await(); + sync.release(1); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - sync.acquire(1); - assertTrue(sync.hasWaiters(c)); - assertEquals(1, sync.getWaitQueueLength(c)); - c.signal(); - sync.release(1); - Thread.sleep(SHORT_DELAY_MS); - sync.acquire(1); - assertFalse(sync.hasWaiters(c)); - assertEquals(0, sync.getWaitQueueLength(c)); - sync.release(1); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertTrue(sync.hasWaiters(c)); + assertEquals(1, sync.getWaitQueueLength(c)); + c.signal(); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertFalse(sync.hasWaiters(c)); + assertEquals(0, sync.getWaitQueueLength(c)); + sync.release(1); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * getWaitQueueLength returns number of waiting threads */ - public void testGetWaitQueueLength() { - final Mutex sync = new Mutex(); + public void testGetWaitQueueLength() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - sync.acquire(1); - threadAssertFalse(sync.hasWaiters(c)); - threadAssertEquals(0, sync.getWaitQueueLength(c)); - c.await(); - sync.release(1); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - sync.acquire(1); - threadAssertTrue(sync.hasWaiters(c)); - threadAssertEquals(1, sync.getWaitQueueLength(c)); - c.await(); - sync.release(1); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - try { - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - sync.acquire(1); - assertTrue(sync.hasWaiters(c)); - assertEquals(2, sync.getWaitQueueLength(c)); - c.signalAll(); - sync.release(1); - Thread.sleep(SHORT_DELAY_MS); - sync.acquire(1); - assertFalse(sync.hasWaiters(c)); - assertEquals(0, sync.getWaitQueueLength(c)); - sync.release(1); - t1.join(SHORT_DELAY_MS); - t2.join(SHORT_DELAY_MS); - assertFalse(t1.isAlive()); - assertFalse(t2.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + threadAssertFalse(sync.hasWaiters(c)); + threadAssertEquals(0, sync.getWaitQueueLength(c)); + c.await(); + sync.release(1); + }}); + + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + threadAssertTrue(sync.hasWaiters(c)); + threadAssertEquals(1, sync.getWaitQueueLength(c)); + c.await(); + sync.release(1); + }}); + + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertTrue(sync.hasWaiters(c)); + assertEquals(2, sync.getWaitQueueLength(c)); + c.signalAll(); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertFalse(sync.hasWaiters(c)); + assertEquals(0, sync.getWaitQueueLength(c)); + sync.release(1); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); } /** * getWaitingThreads returns only and all waiting threads */ - public void testGetWaitingThreads() { - final Mutex sync = new Mutex(); + public void testGetWaitingThreads() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - sync.acquire(1); - threadAssertTrue(sync.getWaitingThreads(c).isEmpty()); - c.await(); - sync.release(1); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - sync.acquire(1); - threadAssertFalse(sync.getWaitingThreads(c).isEmpty()); - c.await(); - sync.release(1); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + threadAssertTrue(sync.getWaitingThreads(c).isEmpty()); + c.await(); + sync.release(1); + }}); + + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + threadAssertFalse(sync.getWaitingThreads(c).isEmpty()); + c.await(); + sync.release(1); + }}); - try { - sync.acquire(1); - assertTrue(sync.getWaitingThreads(c).isEmpty()); - sync.release(1); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - sync.acquire(1); - assertTrue(sync.hasWaiters(c)); - assertTrue(sync.getWaitingThreads(c).contains(t1)); - assertTrue(sync.getWaitingThreads(c).contains(t2)); - c.signalAll(); - sync.release(1); - Thread.sleep(SHORT_DELAY_MS); - sync.acquire(1); - assertFalse(sync.hasWaiters(c)); - assertTrue(sync.getWaitingThreads(c).isEmpty()); - sync.release(1); - t1.join(SHORT_DELAY_MS); - t2.join(SHORT_DELAY_MS); - assertFalse(t1.isAlive()); - assertFalse(t2.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + sync.acquire(1); + assertTrue(sync.getWaitingThreads(c).isEmpty()); + sync.release(1); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertTrue(sync.hasWaiters(c)); + assertTrue(sync.getWaitingThreads(c).contains(t1)); + assertTrue(sync.getWaitingThreads(c).contains(t2)); + c.signalAll(); + sync.release(1); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + assertFalse(sync.hasWaiters(c)); + assertTrue(sync.getWaitingThreads(c).isEmpty()); + sync.release(1); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); } @@ -932,175 +757,114 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { /** * awaitUninterruptibly doesn't abort on interrupt */ - public void testAwaitUninterruptibly() { - final Mutex sync = new Mutex(); + public void testAwaitUninterruptibly() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - sync.acquire(1); - c.awaitUninterruptibly(); - sync.release(1); - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + sync.acquire(1); + c.awaitUninterruptibly(); + sync.release(1); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - sync.acquire(1); - c.signal(); - sync.release(1); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + sync.acquire(1); + c.signal(); + sync.release(1); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * await is interruptible */ - public void testAwait_Interrupt() { - final Mutex sync = new Mutex(); + public void testAwait_Interrupt() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - sync.acquire(1); - c.await(); - sync.release(1); - threadShouldThrow(); - } - catch(InterruptedException success) { - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + c.await(); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * awaitNanos is interruptible */ - public void testAwaitNanos_Interrupt() { - final Mutex sync = new Mutex(); + public void testAwaitNanos_Interrupt() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - sync.acquire(1); - c.awaitNanos(1000 * 1000 * 1000); // 1 sec - sync.release(1); - threadShouldThrow(); - } - catch(InterruptedException success) { - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * awaitUntil is interruptible */ - public void testAwaitUntil_Interrupt() { - final Mutex sync = new Mutex(); + public void testAwaitUntil_Interrupt() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - sync.acquire(1); - java.util.Date d = new java.util.Date(); - c.awaitUntil(new java.util.Date(d.getTime() + 10000)); - sync.release(1); - threadShouldThrow(); - } - catch(InterruptedException success) { - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + java.util.Date d = new java.util.Date(); + c.awaitUntil(new java.util.Date(d.getTime() + 10000)); + }}); - try { - t.start(); - // BEGIN android-changed - Thread.sleep(SMALL_DELAY_MS); // SHORT_DELAY_MS was flaky on Android - t.interrupt(); - t.join(SMALL_DELAY_MS); // SHORT_DELAY_MS was flaky on Android - // END android-changed - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * signalAll wakes up all threads */ - public void testSignalAll() { - final Mutex sync = new Mutex(); + public void testSignalAll() throws InterruptedException { + final Mutex sync = new Mutex(); final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - sync.acquire(1); - c.await(); - sync.release(1); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - sync.acquire(1); - c.await(); - sync.release(1); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - try { - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - sync.acquire(1); - c.signalAll(); - sync.release(1); - t1.join(SHORT_DELAY_MS); - t2.join(SHORT_DELAY_MS); - assertFalse(t1.isAlive()); - assertFalse(t2.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + c.await(); + sync.release(1); + }}); + + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + sync.acquire(1); + c.await(); + sync.release(1); + }}); + + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + sync.acquire(1); + c.signalAll(); + sync.release(1); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); } @@ -1119,25 +883,20 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { /** * A serialized AQS deserializes with current state */ - public void testSerialization() { + public void testSerialization() throws Exception { Mutex l = new Mutex(); l.acquire(1); assertTrue(l.isHeldExclusively()); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - Mutex r = (Mutex) in.readObject(); - assertTrue(r.isHeldExclusively()); - } catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + Mutex r = (Mutex) in.readObject(); + assertTrue(r.isHeldExclusively()); } @@ -1166,136 +925,99 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase { /** * acquireSharedInterruptibly returns after release, but not before */ - public void testAcquireSharedInterruptibly() { + public void testAcquireSharedInterruptibly() throws InterruptedException { final BooleanLatch l = new BooleanLatch(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertFalse(l.isSignalled()); - l.acquireSharedInterruptibly(0); - threadAssertTrue(l.isSignalled()); - } catch(InterruptedException e){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - assertFalse(l.isSignalled()); - Thread.sleep(SHORT_DELAY_MS); - l.releaseShared(0); - assertTrue(l.isSignalled()); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + threadAssertFalse(l.isSignalled()); + l.acquireSharedInterruptibly(0); + threadAssertTrue(l.isSignalled()); + }}); + + t.start(); + assertFalse(l.isSignalled()); + Thread.sleep(SHORT_DELAY_MS); + l.releaseShared(0); + assertTrue(l.isSignalled()); + t.join(); } - + /** * acquireSharedTimed returns after release */ - public void testAsquireSharedTimed() { + public void testAsquireSharedTimed() throws InterruptedException { final BooleanLatch l = new BooleanLatch(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertFalse(l.isSignalled()); - threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000)); - threadAssertTrue(l.isSignalled()); - - } catch(InterruptedException e){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - assertFalse(l.isSignalled()); - Thread.sleep(SHORT_DELAY_MS); - l.releaseShared(0); - assertTrue(l.isSignalled()); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(l.isSignalled()); + long nanos = MILLISECONDS.toNanos(MEDIUM_DELAY_MS); + assertTrue(l.tryAcquireSharedNanos(0, nanos)); + assertTrue(l.isSignalled()); + }}); + + t.start(); + assertFalse(l.isSignalled()); + Thread.sleep(SHORT_DELAY_MS); + l.releaseShared(0); + assertTrue(l.isSignalled()); + t.join(); } - + /** * acquireSharedInterruptibly throws IE if interrupted before released */ - public void testAcquireSharedInterruptibly_InterruptedException() { + public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException { final BooleanLatch l = new BooleanLatch(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertFalse(l.isSignalled()); - l.acquireSharedInterruptibly(0); - threadShouldThrow(); - } catch(InterruptedException success){} - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + threadAssertFalse(l.isSignalled()); + l.acquireSharedInterruptibly(0); + }}); + t.start(); - try { - assertFalse(l.isSignalled()); - t.interrupt(); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + assertFalse(l.isSignalled()); + t.interrupt(); + t.join(); } /** * acquireSharedTimed throws IE if interrupted before released */ - public void testAcquireSharedNanos_InterruptedException() { + public void testAcquireSharedNanos_InterruptedException() throws InterruptedException { final BooleanLatch l = new BooleanLatch(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertFalse(l.isSignalled()); - l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000); - threadShouldThrow(); - } catch(InterruptedException success){} - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(l.isSignalled()); + long nanos = MILLISECONDS.toNanos(SMALL_DELAY_MS); + l.tryAcquireSharedNanos(0, nanos); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - assertFalse(l.isSignalled()); - t.interrupt(); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + assertFalse(l.isSignalled()); + t.interrupt(); + t.join(); } /** * acquireSharedTimed times out if not released before timeout */ - public void testAcquireSharedNanos_Timeout() { + public void testAcquireSharedNanos_Timeout() throws InterruptedException { final BooleanLatch l = new BooleanLatch(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertFalse(l.isSignalled()); - threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000)); - } catch(InterruptedException ie){ - threadUnexpectedException(); - } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(l.isSignalled()); + long nanos = MILLISECONDS.toNanos(SMALL_DELAY_MS); + assertFalse(l.tryAcquireSharedNanos(0, nanos)); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - assertFalse(l.isSignalled()); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + assertFalse(l.isSignalled()); + t.join(); } - } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ArrayBlockingQueueTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ArrayBlockingQueueTest.java index 1deea2c..8fc5cb6 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ArrayBlockingQueueTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ArrayBlockingQueueTest.java @@ -2,15 +2,16 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.io.*; public class ArrayBlockingQueueTest extends JSR166TestCase { @@ -25,14 +26,14 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { private ArrayBlockingQueue populatedQueue(int n) { ArrayBlockingQueue q = new ArrayBlockingQueue(n); assertTrue(q.isEmpty()); - for(int i = 0; i < n; i++) + for (int i = 0; i < n; i++) assertTrue(q.offer(new Integer(i))); assertFalse(q.isEmpty()); assertEquals(0, q.remainingCapacity()); assertEquals(n, q.size()); return q; } - + /** * A new queue has the indicated capacity */ @@ -41,14 +42,13 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { } /** - * Constructor throws IAE if capacity argument nonpositive + * Constructor throws IAE if capacity argument nonpositive */ public void testConstructor2() { try { ArrayBlockingQueue q = new ArrayBlockingQueue(0); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } /** @@ -58,8 +58,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { try { ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -70,8 +69,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -84,8 +82,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { ints[i] = new Integer(i); ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -98,23 +95,19 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { ints[i] = new Integer(i); ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints)); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } /** * Queue contains all elements of collection used to initialize */ public void testConstructor7() { - try { - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints)); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); - } - finally {} + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints)); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); } /** @@ -157,7 +150,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { ArrayBlockingQueue q = new ArrayBlockingQueue(1); q.offer(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -168,7 +161,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { ArrayBlockingQueue q = new ArrayBlockingQueue(1); q.add(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -191,8 +184,8 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { } assertEquals(0, q.remainingCapacity()); q.add(new Integer(SIZE)); - } catch (IllegalStateException success){ - } + shouldThrow(); + } catch (IllegalStateException success) {} } /** @@ -203,8 +196,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { ArrayBlockingQueue q = new ArrayBlockingQueue(1); q.addAll(null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -215,8 +207,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { ArrayBlockingQueue q = populatedQueue(SIZE); q.addAll(q); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } @@ -229,8 +220,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll of a collection with any null elements throws NPE after @@ -244,8 +234,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { ints[i] = new Integer(i); q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll throws ISE if not enough room @@ -258,214 +247,166 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { ints[i] = new Integer(i); q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (IllegalStateException success) {} + } catch (IllegalStateException success) {} } /** * Queue contains all elements, in traversal order, of successful addAll */ public void testAddAll5() { - try { - Integer[] empty = new Integer[0]; - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE); - assertFalse(q.addAll(Arrays.asList(empty))); - assertTrue(q.addAll(Arrays.asList(ints))); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); - } - finally {} + Integer[] empty = new Integer[0]; + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE); + assertFalse(q.addAll(Arrays.asList(empty))); + assertTrue(q.addAll(Arrays.asList(ints))); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); } /** * put(null) throws NPE */ - public void testPutNull() { + public void testPutNull() throws InterruptedException { try { ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE); q.put(null); shouldThrow(); - } - catch (NullPointerException success){ - } - catch (InterruptedException ie) { - unexpectedException(); - } + } catch (NullPointerException success) {} } /** * all elements successfully put are contained */ - public void testPut() { - try { - ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - Integer I = new Integer(i); - q.put(I); - assertTrue(q.contains(I)); - } - assertEquals(0, q.remainingCapacity()); - } - catch (InterruptedException ie) { - unexpectedException(); + public void testPut() throws InterruptedException { + ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + Integer I = new Integer(i); + q.put(I); + assertTrue(q.contains(I)); } + assertEquals(0, q.remainingCapacity()); } /** * put blocks interruptibly if full */ - public void testBlockingPut() { + public void testBlockingPut() throws InterruptedException { final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE); - Thread t = new Thread(new Runnable() { - public void run() { - int added = 0; - try { - for (int i = 0; i < SIZE; ++i) { - q.put(new Integer(i)); - ++added; - } - q.put(new Integer(SIZE)); - threadShouldThrow(); - } catch (InterruptedException ie){ - threadAssertEquals(added, SIZE); - } - }}); - try { - t.start(); - Thread.sleep(MEDIUM_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) + q.put(i); + assertEquals(SIZE, q.size()); + assertEquals(0, q.remainingCapacity()); + try { + q.put(99); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + assertEquals(SIZE, q.size()); + assertEquals(0, q.remainingCapacity()); } /** * put blocks waiting for take when full */ - public void testPutWithTake() { - final ArrayBlockingQueue q = new ArrayBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - int added = 0; - try { - q.put(new Object()); - ++added; - q.put(new Object()); - ++added; - q.put(new Object()); - ++added; - q.put(new Object()); - ++added; - threadShouldThrow(); - } catch (InterruptedException e){ - threadAssertTrue(added >= 2); - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - q.take(); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + public void testPutWithTake() throws InterruptedException { + final int capacity = 2; + final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < capacity + 1; i++) + q.put(i); + try { + q.put(99); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(q.remainingCapacity(), 0); + assertEquals(0, q.take()); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + assertEquals(q.remainingCapacity(), 0); } /** * timed offer times out if full and elements not taken */ - public void testTimedOffer() { + public void testTimedOffer() throws InterruptedException { final ArrayBlockingQueue q = new ArrayBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.put(new Object()); - q.put(new Object()); - threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS)); - q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch (InterruptedException success){} - } - }); - - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.put(new Object()); + q.put(new Object()); + assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS)); + try { + q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * take retrieves elements in FIFO order */ - public void testTake() { - try { - ArrayBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.take()).intValue()); - } - } catch (InterruptedException e){ - unexpectedException(); - } + public void testTake() throws InterruptedException { + ArrayBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.take()); + } } /** * take blocks interruptibly when empty */ - public void testTakeFromEmpty() { + public void testTakeFromEmpty() throws InterruptedException { final ArrayBlockingQueue q = new ArrayBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.take(); - threadShouldThrow(); - } catch (InterruptedException success){ } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new ThreadShouldThrow(InterruptedException.class) { + public void realRun() throws InterruptedException { + q.take(); + }}; + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * Take removes existing elements until empty, then blocks interruptibly */ - public void testBlockingTake() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - ArrayBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - threadAssertEquals(i, ((Integer)q.take()).intValue()); - } - q.take(); - threadShouldThrow(); - } catch (InterruptedException success){ - } - }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + public void testBlockingTake() throws InterruptedException { + final ArrayBlockingQueue q = populatedQueue(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.take()); + } + try { + q.take(); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } @@ -475,7 +416,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { public void testPoll() { ArrayBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.poll()).intValue()); + assertEquals(i, q.poll()); } assertNull(q.poll()); } @@ -483,86 +424,70 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { /** * timed pool with zero timeout succeeds when non-empty, else times out */ - public void testTimedPoll0() { - try { - ArrayBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue()); - } - assertNull(q.poll(0, TimeUnit.MILLISECONDS)); - } catch (InterruptedException e){ - unexpectedException(); - } + public void testTimedPoll0() throws InterruptedException { + ArrayBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(0, MILLISECONDS)); + } + assertNull(q.poll(0, MILLISECONDS)); } /** * timed pool with nonzero timeout succeeds when non-empty, else times out */ - public void testTimedPoll() { - try { - ArrayBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue()); - } - assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (InterruptedException e){ - unexpectedException(); - } + public void testTimedPoll() throws InterruptedException { + ArrayBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS)); + } + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); } /** * Interrupted timed poll throws InterruptedException instead of * returning timeout status */ - public void testInterruptedTimedPoll() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - ArrayBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue()); - } - threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (InterruptedException success){ - } - }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + public void testInterruptedTimedPoll() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + ArrayBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));; + } + try { + q.poll(SMALL_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * timed poll before a delayed offer fails; after offer succeeds; * on interruption throws */ - public void testTimedPollWithOffer() { + public void testTimedPollWithOffer() throws InterruptedException { final ArrayBlockingQueue q = new ArrayBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch (InterruptedException success) { } - } - }); - try { - t.start(); - Thread.sleep(SMALL_DELAY_MS); - assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); + assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS)); + try { + q.poll(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS)); + t.interrupt(); + t.join(); + } /** @@ -571,10 +496,10 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { public void testPeek() { ArrayBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.peek()).intValue()); - q.poll(); + assertEquals(i, q.peek()); + assertEquals(i, q.poll()); assertTrue(q.peek() == null || - i != ((Integer)q.peek()).intValue()); + !q.peek().equals(i)); } assertNull(q.peek()); } @@ -585,14 +510,13 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { public void testElement() { ArrayBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.element()).intValue()); - q.poll(); + assertEquals(i, q.element()); + assertEquals(i, q.poll()); } try { q.element(); shouldThrow(); - } - catch (NoSuchElementException success) {} + } catch (NoSuchElementException success) {} } /** @@ -601,13 +525,12 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { public void testRemove() { ArrayBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.remove()).intValue()); + assertEquals(i, q.remove()); } try { q.remove(); shouldThrow(); - } catch (NoSuchElementException success){ - } + } catch (NoSuchElementException success) {} } /** @@ -624,7 +547,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { } assertTrue(q.isEmpty()); } - + /** * contains(x) reports true when elements added but not yet removed */ @@ -632,7 +555,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { ArrayBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { assertTrue(q.contains(new Integer(i))); - q.poll(); + assertEquals(i, q.poll()); assertFalse(q.contains(new Integer(i))); } } @@ -705,68 +628,56 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { /** * toArray contains all elements */ - public void testToArray() { + public void testToArray() throws InterruptedException { ArrayBlockingQueue q = populatedQueue(SIZE); Object[] o = q.toArray(); - try { - for(int i = 0; i < o.length; i++) + for (int i = 0; i < o.length; i++) assertEquals(o[i], q.take()); - } catch (InterruptedException e){ - unexpectedException(); - } } /** * toArray(a) contains all elements */ - public void testToArray2() { + public void testToArray2() throws InterruptedException { ArrayBlockingQueue q = populatedQueue(SIZE); Integer[] ints = new Integer[SIZE]; ints = (Integer[])q.toArray(ints); - try { - for(int i = 0; i < ints.length; i++) - assertEquals(ints[i], q.take()); - } catch (InterruptedException e){ - unexpectedException(); - } + for (int i = 0; i < ints.length; i++) + assertEquals(ints[i], q.take()); } /** * toArray(null) throws NPE */ public void testToArray_BadArg() { + ArrayBlockingQueue q = populatedQueue(SIZE); try { - ArrayBlockingQueue q = populatedQueue(SIZE); Object o[] = q.toArray(null); shouldThrow(); - } catch(NullPointerException success){} + } catch (NullPointerException success) {} } /** * toArray with incompatible array type throws CCE */ public void testToArray1_BadArg() { + ArrayBlockingQueue q = populatedQueue(SIZE); try { - ArrayBlockingQueue q = populatedQueue(SIZE); - Object o[] = q.toArray(new String[10] ); + Object o[] = q.toArray(new String[10]); shouldThrow(); - } catch(ArrayStoreException success){} + } catch (ArrayStoreException success) {} } - + /** * iterator iterates through all elements */ - public void testIterator() { + public void testIterator() throws InterruptedException { ArrayBlockingQueue q = populatedQueue(SIZE); Iterator it = q.iterator(); - try { - while(it.hasNext()){ - assertEquals(it.next(), q.take()); - } - } catch (InterruptedException e){ - unexpectedException(); - } + while (it.hasNext()) { + assertEquals(it.next(), q.take()); + } } /** @@ -781,10 +692,10 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { Iterator it = q.iterator(); it.next(); it.remove(); - + it = q.iterator(); - assertEquals(it.next(), one); - assertEquals(it.next(), three); + assertSame(it.next(), one); + assertSame(it.next(), three); assertFalse(it.hasNext()); } @@ -801,8 +712,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { int k = 0; for (Iterator it = q.iterator(); it.hasNext();) { - int i = ((Integer)(it.next())).intValue(); - assertEquals(++k, i); + assertEquals(++k, it.next()); } assertEquals(3, k); } @@ -815,14 +725,9 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { q.add(one); q.add(two); q.add(three); - try { - for (Iterator it = q.iterator(); it.hasNext();) { - q.remove(); - it.next(); - } - } - catch (ConcurrentModificationException e) { - unexpectedException(); + for (Iterator it = q.iterator(); it.hasNext();) { + q.remove(); + it.next(); } assertEquals(0, q.size()); } @@ -837,7 +742,7 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { for (int i = 0; i < SIZE; ++i) { assertTrue(s.indexOf(String.valueOf(i)) >= 0); } - } + } /** @@ -848,33 +753,20 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { q.add(one); q.add(two); ExecutorService executor = Executors.newFixedThreadPool(2); - executor.execute(new Runnable() { - public void run() { - threadAssertFalse(q.offer(three)); - try { - threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertEquals(0, q.remainingCapacity()); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(q.offer(three)); + assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS)); + assertEquals(0, q.remainingCapacity()); + }}); + + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); + assertSame(one, q.take()); + }}); - executor.execute(new Runnable() { - public void run() { - try { - Thread.sleep(SMALL_DELAY_MS); - threadAssertEquals(one, q.take()); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); - joinPool(executor); - } /** @@ -883,91 +775,73 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { public void testPollInExecutor() { final ArrayBlockingQueue q = new ArrayBlockingQueue(2); ExecutorService executor = Executors.newFixedThreadPool(2); - executor.execute(new Runnable() { - public void run() { - threadAssertNull(q.poll()); - try { - threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(q.isEmpty()); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll()); + assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS)); + assertTrue(q.isEmpty()); + }}); + + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); + q.put(one); + }}); - executor.execute(new Runnable() { - public void run() { - try { - Thread.sleep(SMALL_DELAY_MS); - q.put(one); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); - joinPool(executor); } /** * A deserialized serialized queue has same elements in same order */ - public void testSerialization() { + public void testSerialization() throws Exception { ArrayBlockingQueue q = populatedQueue(SIZE); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(q); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - ArrayBlockingQueue r = (ArrayBlockingQueue)in.readObject(); - assertEquals(q.size(), r.size()); - while (!q.isEmpty()) - assertEquals(q.remove(), r.remove()); - } catch(Exception e){ - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + ArrayBlockingQueue r = (ArrayBlockingQueue)in.readObject(); + assertEquals(q.size(), r.size()); + while (!q.isEmpty()) + assertEquals(q.remove(), r.remove()); } /** * drainTo(null) throws NPE - */ + */ public void testDrainToNull() { ArrayBlockingQueue q = populatedQueue(SIZE); try { q.drainTo(null); shouldThrow(); - } catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * drainTo(this) throws IAE - */ + */ public void testDrainToSelf() { ArrayBlockingQueue q = populatedQueue(SIZE); try { q.drainTo(q); shouldThrow(); - } catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } /** * drainTo(c) empties queue into another collection c - */ + */ public void testDrainTo() { ArrayBlockingQueue q = populatedQueue(SIZE); ArrayList l = new ArrayList(); q.drainTo(l); assertEquals(q.size(), 0); assertEquals(l.size(), SIZE); - for (int i = 0; i < SIZE; ++i) + for (int i = 0; i < SIZE; ++i) assertEquals(l.get(i), new Integer(i)); q.add(zero); q.add(one); @@ -978,80 +852,69 @@ public class ArrayBlockingQueueTest extends JSR166TestCase { q.drainTo(l); assertEquals(q.size(), 0); assertEquals(l.size(), 2); - for (int i = 0; i < 2; ++i) + for (int i = 0; i < 2; ++i) assertEquals(l.get(i), new Integer(i)); } /** * drainTo empties full queue, unblocking a waiting put. - */ - public void testDrainToWithActivePut() { + */ + public void testDrainToWithActivePut() throws InterruptedException { final ArrayBlockingQueue q = populatedQueue(SIZE); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.put(new Integer(SIZE+1)); - } catch (InterruptedException ie){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - ArrayList l = new ArrayList(); - q.drainTo(l); - assertTrue(l.size() >= SIZE); - for (int i = 0; i < SIZE; ++i) - assertEquals(l.get(i), new Integer(i)); - t.join(); - assertTrue(q.size() + l.size() >= SIZE); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.put(new Integer(SIZE+1)); + }}); + + t.start(); + ArrayList l = new ArrayList(); + q.drainTo(l); + assertTrue(l.size() >= SIZE); + for (int i = 0; i < SIZE; ++i) + assertEquals(l.get(i), new Integer(i)); + t.join(); + assertTrue(q.size() + l.size() >= SIZE); } /** * drainTo(null, n) throws NPE - */ + */ public void testDrainToNullN() { ArrayBlockingQueue q = populatedQueue(SIZE); try { q.drainTo(null, 0); shouldThrow(); - } catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * drainTo(this, n) throws IAE - */ + */ public void testDrainToSelfN() { ArrayBlockingQueue q = populatedQueue(SIZE); try { q.drainTo(q, 0); shouldThrow(); - } catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } /** * drainTo(c, n) empties first max {n, size} elements of queue into c - */ + */ public void testDrainToN() { ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2); for (int i = 0; i < SIZE + 2; ++i) { - for(int j = 0; j < SIZE; j++) + for (int j = 0; j < SIZE; j++) assertTrue(q.offer(new Integer(j))); ArrayList l = new ArrayList(); q.drainTo(l, i); int k = (i < SIZE)? i : SIZE; assertEquals(l.size(), k); assertEquals(q.size(), SIZE-k); - for (int j = 0; j < k; ++j) + for (int j = 0; j < k; ++j) assertEquals(l.get(j), new Integer(j)); while (q.poll() != null) ; } } - } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ArrayDequeTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ArrayDequeTest.java new file mode 100644 index 0000000..cec1d58 --- /dev/null +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ArrayDequeTest.java @@ -0,0 +1,630 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + */ + +package tests.api.java.util.concurrent; // android-added + +import junit.framework.*; +import java.util.*; +import java.util.concurrent.*; + +public class ArrayDequeTest extends JSR166TestCase { + public static Test suite() { + return new TestSuite(ArrayDequeTest.class); + } + + /** + * Create a queue of given size containing consecutive + * Integers 0 ... n. + */ + private ArrayDeque populatedDeque(int n) { + ArrayDeque q = new ArrayDeque(); + assertTrue(q.isEmpty()); + for (int i = 0; i < n; ++i) + assertTrue(q.offerLast(new Integer(i))); + assertFalse(q.isEmpty()); + assertEquals(n, q.size()); + return q; + } + + /** + * new queue is empty + */ + public void testConstructor1() { + assertEquals(0, new ArrayDeque().size()); + } + + /** + * Initializing from null Collection throws NPE + */ + public void testConstructor3() { + try { + ArrayDeque q = new ArrayDeque((Collection)null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Queue contains all elements of collection used to initialize + + */ + public void testConstructor6() { + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + ArrayDeque q = new ArrayDeque(Arrays.asList(ints)); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.pollFirst()); + } + + /** + * isEmpty is true before add, false after + */ + public void testEmpty() { + ArrayDeque q = new ArrayDeque(); + assertTrue(q.isEmpty()); + q.add(new Integer(1)); + assertFalse(q.isEmpty()); + q.add(new Integer(2)); + q.removeFirst(); + q.removeFirst(); + assertTrue(q.isEmpty()); + } + + /** + * size changes when elements added and removed + */ + public void testSize() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(SIZE-i, q.size()); + q.removeFirst(); + } + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.size()); + q.add(new Integer(i)); + } + } + + /** + * push(null) throws NPE + */ + public void testPushNull() { + try { + ArrayDeque q = new ArrayDeque(1); + q.push(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * peekFirst returns element inserted with push + */ + public void testPush() { + ArrayDeque q = populatedDeque(3); + q.pollLast(); + q.push(four); + assertSame(four, q.peekFirst()); + } + + /** + * pop removes next element, or throws NSEE if empty + */ + public void testPop() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.pop()); + } + try { + q.pop(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } + + /** + * offer(null) throws NPE + */ + public void testOfferFirstNull() { + try { + ArrayDeque q = new ArrayDeque(); + q.offerFirst(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * OfferFirst succeeds + */ + public void testOfferFirst() { + ArrayDeque q = new ArrayDeque(); + assertTrue(q.offerFirst(new Integer(0))); + assertTrue(q.offerFirst(new Integer(1))); + } + + /** + * OfferLast succeeds + */ + public void testOfferLast() { + ArrayDeque q = new ArrayDeque(); + assertTrue(q.offerLast(new Integer(0))); + assertTrue(q.offerLast(new Integer(1))); + } + + /** + * add succeeds + */ + public void testAdd() { + ArrayDeque q = new ArrayDeque(); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.size()); + assertTrue(q.add(new Integer(i))); + } + } + + /** + * addAll(null) throws NPE + */ + public void testAddAll1() { + try { + ArrayDeque q = new ArrayDeque(); + q.addAll(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Queue contains all elements, in traversal order, of successful addAll + */ + public void testAddAll5() { + Integer[] empty = new Integer[0]; + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + ArrayDeque q = new ArrayDeque(); + assertFalse(q.addAll(Arrays.asList(empty))); + assertTrue(q.addAll(Arrays.asList(ints))); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.pollFirst()); + } + + /** + * pollFirst succeeds unless empty + */ + public void testPollFirst() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.pollFirst()); + } + assertNull(q.pollFirst()); + } + + /** + * pollLast succeeds unless empty + */ + public void testPollLast() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = SIZE-1; i >= 0; --i) { + assertEquals(i, q.pollLast()); + } + assertNull(q.pollLast()); + } + + /** + * poll succeeds unless empty + */ + public void testPoll() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll()); + } + assertNull(q.poll()); + } + + /** + * remove removes next element, or throws NSEE if empty + */ + public void testRemove() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.remove()); + } + try { + q.remove(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } + + /** + * peekFirst returns next element, or null if empty + */ + public void testPeekFirst() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.peekFirst()); + assertEquals(i, q.pollFirst()); + assertTrue(q.peekFirst() == null || + !q.peekFirst().equals(i)); + } + assertNull(q.peekFirst()); + } + + /** + * peek returns next element, or null if empty + */ + public void testPeek() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.peek()); + assertEquals(i, q.poll()); + assertTrue(q.peek() == null || + !q.peek().equals(i)); + } + assertNull(q.peek()); + } + + /** + * peekLast returns next element, or null if empty + */ + public void testPeekLast() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = SIZE-1; i >= 0; --i) { + assertEquals(i, q.peekLast()); + assertEquals(i, q.pollLast()); + assertTrue(q.peekLast() == null || + !q.peekLast().equals(i)); + } + assertNull(q.peekLast()); + } + + /** + * getFirst returns next getFirst, or throws NSEE if empty + */ + public void testFirstElement() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.getFirst()); + assertEquals(i, q.pollFirst()); + } + try { + q.getFirst(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } + + /** + * getLast returns next element, or throws NSEE if empty + */ + public void testLastElement() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = SIZE-1; i >= 0; --i) { + assertEquals(i, q.getLast()); + assertEquals(i, q.pollLast()); + } + try { + q.getLast(); + shouldThrow(); + } catch (NoSuchElementException success) {} + assertNull(q.peekLast()); + } + + + /** + * removeFirst removes next element, or throws NSEE if empty + */ + public void testRemoveFirst() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.removeFirst()); + } + try { + q.removeFirst(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } + + /** + * removeFirstOccurrence(x) removes x and returns true if present + */ + public void testRemoveFirstOccurrence() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 1; i < SIZE; i+=2) { + assertTrue(q.removeFirstOccurrence(new Integer(i))); + } + for (int i = 0; i < SIZE; i+=2) { + assertTrue(q.removeFirstOccurrence(new Integer(i))); + assertFalse(q.removeFirstOccurrence(new Integer(i+1))); + } + assertTrue(q.isEmpty()); + } + + /** + * removeLastOccurrence(x) removes x and returns true if present + */ + public void testRemoveLastOccurrence() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 1; i < SIZE; i+=2) { + assertTrue(q.removeLastOccurrence(new Integer(i))); + } + for (int i = 0; i < SIZE; i+=2) { + assertTrue(q.removeLastOccurrence(new Integer(i))); + assertFalse(q.removeLastOccurrence(new Integer(i+1))); + } + assertTrue(q.isEmpty()); + } + + /** + * contains(x) reports true when elements added but not yet removed + */ + public void testContains() { + ArrayDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertTrue(q.contains(new Integer(i))); + assertEquals(i, q.pollFirst()); + assertFalse(q.contains(new Integer(i))); + } + } + + /** + * clear removes all elements + */ + public void testClear() { + ArrayDeque q = populatedDeque(SIZE); + q.clear(); + assertTrue(q.isEmpty()); + assertEquals(0, q.size()); + assertTrue(q.add(new Integer(1))); + assertFalse(q.isEmpty()); + q.clear(); + assertTrue(q.isEmpty()); + } + + /** + * containsAll(c) is true when c contains a subset of elements + */ + public void testContainsAll() { + ArrayDeque q = populatedDeque(SIZE); + ArrayDeque p = new ArrayDeque(); + for (int i = 0; i < SIZE; ++i) { + assertTrue(q.containsAll(p)); + assertFalse(p.containsAll(q)); + assertTrue(p.add(new Integer(i))); + } + assertTrue(p.containsAll(q)); + } + + /** + * retainAll(c) retains only those elements of c and reports true if changed + */ + public void testRetainAll() { + ArrayDeque q = populatedDeque(SIZE); + ArrayDeque p = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + boolean changed = q.retainAll(p); + assertEquals(changed, (i > 0)); + assertTrue(q.containsAll(p)); + assertEquals(SIZE-i, q.size()); + p.removeFirst(); + } + } + + /** + * removeAll(c) removes only those elements of c and reports true if changed + */ + public void testRemoveAll() { + for (int i = 1; i < SIZE; ++i) { + ArrayDeque q = populatedDeque(SIZE); + ArrayDeque p = populatedDeque(i); + assertTrue(q.removeAll(p)); + assertEquals(SIZE-i, q.size()); + for (int j = 0; j < i; ++j) { + assertFalse(q.contains(p.removeFirst())); + } + } + } + + /** + * toArray contains all elements + */ + public void testToArray() { + ArrayDeque q = populatedDeque(SIZE); + Object[] o = q.toArray(); + Arrays.sort(o); + for (int i = 0; i < o.length; i++) + assertEquals(o[i], q.pollFirst()); + } + + /** + * toArray(a) contains all elements + */ + public void testToArray2() { + ArrayDeque q = populatedDeque(SIZE); + Integer[] ints = new Integer[SIZE]; + ints = (Integer[])q.toArray(ints); + Arrays.sort(ints); + for (int i = 0; i < ints.length; i++) + assertEquals(ints[i], q.pollFirst()); + } + + /** + * toArray(null) throws NPE + */ + public void testToArray_BadArg() { + ArrayDeque l = new ArrayDeque(); + l.add(new Object()); + try { + Object o[] = l.toArray(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * toArray with incompatible array type throws CCE + */ + public void testToArray1_BadArg() { + ArrayDeque l = new ArrayDeque(); + l.add(new Integer(5)); + try { + Object o[] = l.toArray(new String[10]); + shouldThrow(); + } catch (ArrayStoreException success) {} + } + + /** + * iterator iterates through all elements + */ + public void testIterator() { + ArrayDeque q = populatedDeque(SIZE); + int i = 0; + Iterator it = q.iterator(); + while (it.hasNext()) { + assertTrue(q.contains(it.next())); + ++i; + } + assertEquals(i, SIZE); + } + + /** + * iterator ordering is FIFO + */ + public void testIteratorOrdering() { + final ArrayDeque q = new ArrayDeque(); + q.add(new Integer(1)); + q.add(new Integer(2)); + q.add(new Integer(3)); + int k = 0; + for (Iterator it = q.iterator(); it.hasNext();) { + assertEquals(++k, it.next()); + } + + assertEquals(3, k); + } + + /** + * iterator.remove removes current element + */ + public void testIteratorRemove () { + final ArrayDeque q = new ArrayDeque(); + final Random rng = new Random(); + for (int iters = 0; iters < 100; ++iters) { + int max = rng.nextInt(5) + 2; + int split = rng.nextInt(max-1) + 1; + for (int j = 1; j <= max; ++j) + q.add(new Integer(j)); + Iterator it = q.iterator(); + for (int j = 1; j <= split; ++j) + assertEquals(it.next(), new Integer(j)); + it.remove(); + assertEquals(it.next(), new Integer(split+1)); + for (int j = 1; j <= split; ++j) + q.remove(new Integer(j)); + it = q.iterator(); + for (int j = split+1; j <= max; ++j) { + assertEquals(it.next(), new Integer(j)); + it.remove(); + } + assertFalse(it.hasNext()); + assertTrue(q.isEmpty()); + } + } + + /** + * Descending iterator iterates through all elements + */ + public void testDescendingIterator() { + ArrayDeque q = populatedDeque(SIZE); + int i = 0; + Iterator it = q.descendingIterator(); + while (it.hasNext()) { + assertTrue(q.contains(it.next())); + ++i; + } + assertEquals(i, SIZE); + assertFalse(it.hasNext()); + try { + it.next(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } + + /** + * Descending iterator ordering is reverse FIFO + */ + public void testDescendingIteratorOrdering() { + final ArrayDeque q = new ArrayDeque(); + for (int iters = 0; iters < 100; ++iters) { + q.add(new Integer(3)); + q.add(new Integer(2)); + q.add(new Integer(1)); + int k = 0; + for (Iterator it = q.descendingIterator(); it.hasNext();) { + assertEquals(++k, it.next()); + } + + assertEquals(3, k); + q.remove(); + q.remove(); + q.remove(); + } + } + + /** + * descendingIterator.remove removes current element + */ + public void testDescendingIteratorRemove () { + final ArrayDeque q = new ArrayDeque(); + final Random rng = new Random(); + for (int iters = 0; iters < 100; ++iters) { + int max = rng.nextInt(5) + 2; + int split = rng.nextInt(max-1) + 1; + for (int j = max; j >= 1; --j) + q.add(new Integer(j)); + Iterator it = q.descendingIterator(); + for (int j = 1; j <= split; ++j) + assertEquals(it.next(), new Integer(j)); + it.remove(); + assertEquals(it.next(), new Integer(split+1)); + for (int j = 1; j <= split; ++j) + q.remove(new Integer(j)); + it = q.descendingIterator(); + for (int j = split+1; j <= max; ++j) { + assertEquals(it.next(), new Integer(j)); + it.remove(); + } + assertFalse(it.hasNext()); + assertTrue(q.isEmpty()); + } + } + + + /** + * toString contains toStrings of elements + */ + public void testToString() { + ArrayDeque q = populatedDeque(SIZE); + String s = q.toString(); + for (int i = 0; i < SIZE; ++i) { + assertTrue(s.indexOf(String.valueOf(i)) >= 0); + } + } + + /** + * peekFirst returns element inserted with addFirst + */ + public void testAddFirst() { + ArrayDeque q = populatedDeque(3); + q.addFirst(four); + assertSame(four, q.peekFirst()); + } + + /** + * peekLast returns element inserted with addLast + */ + public void testAddLast() { + ArrayDeque q = populatedDeque(3); + q.addLast(four); + assertSame(four, q.peekLast()); + } + +} diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicBooleanTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicBooleanTest.java index c76196b..b2d91b8 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicBooleanTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicBooleanTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.atomic.*; @@ -21,8 +21,8 @@ public class AtomicBooleanTest extends JSR166TestCase { * constructor initializes to given value */ public void testConstructor() { - AtomicBoolean ai = new AtomicBoolean(true); - assertEquals(true,ai.get()); + assertTrue(new AtomicBoolean(true).get()); + assertFalse(new AtomicBoolean(false).get()); } /** @@ -30,7 +30,7 @@ public class AtomicBooleanTest extends JSR166TestCase { */ public void testConstructor2() { AtomicBoolean ai = new AtomicBoolean(); - assertEquals(false,ai.get()); + assertFalse(ai.get()); } /** @@ -38,12 +38,23 @@ public class AtomicBooleanTest extends JSR166TestCase { */ public void testGetSet() { AtomicBoolean ai = new AtomicBoolean(true); - assertEquals(true,ai.get()); + assertTrue(ai.get()); ai.set(false); - assertEquals(false,ai.get()); + assertFalse(ai.get()); ai.set(true); - assertEquals(true,ai.get()); - + assertTrue(ai.get()); + } + + /** + * get returns the last value lazySet in same thread + */ + public void testGetLazySet() { + AtomicBoolean ai = new AtomicBoolean(true); + assertTrue(ai.get()); + ai.lazySet(false); + assertFalse(ai.get()); + ai.lazySet(true); + assertTrue(ai.get()); } /** @@ -52,48 +63,44 @@ public class AtomicBooleanTest extends JSR166TestCase { public void testCompareAndSet() { AtomicBoolean ai = new AtomicBoolean(true); assertTrue(ai.compareAndSet(true,false)); - assertEquals(false,ai.get()); + assertFalse(ai.get()); assertTrue(ai.compareAndSet(false,false)); - assertEquals(false,ai.get()); + assertFalse(ai.get()); assertFalse(ai.compareAndSet(true,false)); - assertFalse((ai.get())); + assertFalse(ai.get()); assertTrue(ai.compareAndSet(false,true)); - assertEquals(true,ai.get()); + assertTrue(ai.get()); } /** * compareAndSet in one thread enables another waiting for value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws Exception { final AtomicBoolean ai = new AtomicBoolean(true); - Thread t = new Thread(new Runnable() { - public void run() { - while(!ai.compareAndSet(false, true)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(ai.compareAndSet(true, false)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!ai.compareAndSet(false, true)) Thread.yield(); + }}); + + t.start(); + assertTrue(ai.compareAndSet(true, false)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); } /** * repeated weakCompareAndSet succeeds in changing value when equal - * to expected + * to expected */ public void testWeakCompareAndSet() { AtomicBoolean ai = new AtomicBoolean(true); - while(!ai.weakCompareAndSet(true,false)); - assertEquals(false,ai.get()); - while(!ai.weakCompareAndSet(false,false)); - assertEquals(false,ai.get()); - while(!ai.weakCompareAndSet(false,true)); - assertEquals(true,ai.get()); + while (!ai.weakCompareAndSet(true,false)); + assertFalse(ai.get()); + while (!ai.weakCompareAndSet(false,false)); + assertFalse(ai.get()); + while (!ai.weakCompareAndSet(false,true)); + assertTrue(ai.get()); } /** @@ -104,37 +111,32 @@ public class AtomicBooleanTest extends JSR166TestCase { assertEquals(true,ai.getAndSet(false)); assertEquals(false,ai.getAndSet(false)); assertEquals(false,ai.getAndSet(true)); - assertEquals(true,ai.get()); + assertTrue(ai.get()); } /** * a deserialized serialized atomic holds same value */ - public void testSerialization() { + public void testSerialization() throws Exception { AtomicBoolean l = new AtomicBoolean(); - try { - l.set(true); - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - AtomicBoolean r = (AtomicBoolean) in.readObject(); - assertEquals(l.get(), r.get()); - } catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + l.set(true); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + AtomicBoolean r = (AtomicBoolean) in.readObject(); + assertEquals(l.get(), r.get()); } /** * toString returns current value. - */ + */ public void testToString() { - AtomicBoolean ai = new AtomicBoolean(); + AtomicBoolean ai = new AtomicBoolean(); assertEquals(ai.toString(), Boolean.toString(false)); ai.set(true); assertEquals(ai.toString(), Boolean.toString(true)); diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerArrayTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerArrayTest.java index d8afe4e..838296d 100644 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerArrayTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerArrayTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.atomic.*; @@ -24,7 +24,7 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { */ public void testConstructor() { AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); - for (int i = 0; i < SIZE; ++i) + for (int i = 0; i < SIZE; ++i) assertEquals(0,ai.get(i)); } @@ -35,10 +35,8 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { try { int[] a = null; AtomicIntegerArray ai = new AtomicIntegerArray(a); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + shouldThrow(); + } catch (NullPointerException success) {} } /** @@ -48,30 +46,34 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { int[] a = { 17, 3, -42, 99, -7}; AtomicIntegerArray ai = new AtomicIntegerArray(a); assertEquals(a.length, ai.length()); - for (int i = 0; i < a.length; ++i) + for (int i = 0; i < a.length; ++i) assertEquals(a[i], ai.get(i)); } /** * get and set for out of bound indices throw IndexOutOfBoundsException */ - public void testIndexing(){ + public void testIndexing() { AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); try { ai.get(SIZE); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } try { ai.get(-1); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } try { ai.set(SIZE, 0); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } try { ai.set(-1, 0); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } } @@ -79,7 +81,7 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { * get returns the last value set at index */ public void testGetSet() { - AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(1,ai.get(i)); @@ -91,17 +93,32 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { } /** + * get returns the last value lazySet at index by same thread + */ + public void testGetLazySet() { + AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + for (int i = 0; i < SIZE; ++i) { + ai.lazySet(i, 1); + assertEquals(1,ai.get(i)); + ai.lazySet(i, 2); + assertEquals(2,ai.get(i)); + ai.lazySet(i, -3); + assertEquals(-3,ai.get(i)); + } + } + + /** * compareAndSet succeeds in changing value if equal to expected else fails */ public void testCompareAndSet() { - AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertTrue(ai.compareAndSet(i, 1,2)); assertTrue(ai.compareAndSet(i, 2,-4)); assertEquals(-4,ai.get(i)); assertFalse(ai.compareAndSet(i, -5,7)); - assertFalse((7 == ai.get(i))); + assertEquals(-4,ai.get(i)); assertTrue(ai.compareAndSet(i, -4,7)); assertEquals(7,ai.get(i)); } @@ -111,37 +128,34 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { * compareAndSet in one thread enables another waiting for value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws Exception { final AtomicIntegerArray a = new AtomicIntegerArray(1); a.set(0, 1); - Thread t = new Thread(new Runnable() { - public void run() { - while(!a.compareAndSet(0, 2, 3)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(a.compareAndSet(0, 1, 2)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(a.get(0), 3); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!a.compareAndSet(0, 2, 3)) + Thread.yield(); + }}); + + t.start(); + assertTrue(a.compareAndSet(0, 1, 2)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertEquals(a.get(0), 3); } /** * repeated weakCompareAndSet succeeds in changing value when equal - * to expected + * to expected */ public void testWeakCompareAndSet() { - AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); - while(!ai.weakCompareAndSet(i, 1,2)); - while(!ai.weakCompareAndSet(i, 2,-4)); + while (!ai.weakCompareAndSet(i, 1,2)); + while (!ai.weakCompareAndSet(i, 2,-4)); assertEquals(-4,ai.get(i)); - while(!ai.weakCompareAndSet(i, -4,7)); + while (!ai.weakCompareAndSet(i, -4,7)); assertEquals(7,ai.get(i)); } } @@ -150,7 +164,7 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { * getAndSet returns previous value and sets to given value at given index */ public void testGetAndSet() { - AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(1,ai.getAndSet(i,0)); @@ -163,7 +177,7 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { * getAndAdd returns previous value and adds given value */ public void testGetAndAdd() { - AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(1,ai.getAndAdd(i,2)); @@ -177,7 +191,7 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { * getAndDecrement returns previous value and decrements */ public void testGetAndDecrement() { - AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(1,ai.getAndDecrement(i)); @@ -190,7 +204,7 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { * getAndIncrement returns previous value and increments */ public void testGetAndIncrement() { - AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(1,ai.getAndIncrement(i)); @@ -207,7 +221,7 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { * addAndGet adds given value to current, and returns current value */ public void testAddAndGet() { - AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(3,ai.addAndGet(i,2)); @@ -221,7 +235,7 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { * decrementAndGet decrements and returns current value */ public void testDecrementAndGet() { - AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(0,ai.decrementAndGet(i)); @@ -235,7 +249,7 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { * incrementAndGet increments and returns current value */ public void testIncrementAndGet() { - AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(2,ai.incrementAndGet(i)); @@ -249,7 +263,7 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { } static final int COUNTDOWN = 100000; - + class Counter implements Runnable { final AtomicIntegerArray ai; volatile int counts; @@ -276,57 +290,47 @@ public class AtomicIntegerArrayTest extends JSR166TestCase { * Multiple threads using same array of counters successfully * update a number of times equal to total count */ - public void testCountingInMultipleThreads() { - try { - final AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); - for (int i = 0; i < SIZE; ++i) - ai.set(i, COUNTDOWN); - Counter c1 = new Counter(ai); - Counter c2 = new Counter(ai); - Thread t1 = new Thread(c1); - Thread t2 = new Thread(c2); - t1.start(); - t2.start(); - t1.join(); - t2.join(); - assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN); - } - catch(InterruptedException ie) { - unexpectedException(); - } + public void testCountingInMultipleThreads() throws InterruptedException { + final AtomicIntegerArray ai = new AtomicIntegerArray(SIZE); + for (int i = 0; i < SIZE; ++i) + ai.set(i, COUNTDOWN); + Counter c1 = new Counter(ai); + Counter c2 = new Counter(ai); + Thread t1 = new Thread(c1); + Thread t2 = new Thread(c2); + t1.start(); + t2.start(); + t1.join(); + t2.join(); + assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN); } /** * a deserialized serialized array holds same values */ - public void testSerialization() { - AtomicIntegerArray l = new AtomicIntegerArray(SIZE); - for (int i = 0; i < SIZE; ++i) + public void testSerialization() throws Exception { + AtomicIntegerArray l = new AtomicIntegerArray(SIZE); + for (int i = 0; i < SIZE; ++i) l.set(i, -i); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - AtomicIntegerArray r = (AtomicIntegerArray) in.readObject(); - for (int i = 0; i < SIZE; ++i) { - assertEquals(l.get(i), r.get(i)); - } - } catch(Exception e){ - e.printStackTrace(); - unexpectedException(); + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + AtomicIntegerArray r = (AtomicIntegerArray) in.readObject(); + for (int i = 0; i < SIZE; ++i) { + assertEquals(l.get(i), r.get(i)); } } /** * toString returns current value. - */ + */ public void testToString() { int[] a = { 17, 3, -42, 99, -7}; AtomicIntegerArray ai = new AtomicIntegerArray(a); diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerFieldUpdaterTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerFieldUpdaterTest.java index a4ec85e..383e30b 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerFieldUpdaterTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerFieldUpdaterTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import java.util.concurrent.atomic.*; import junit.framework.*; @@ -24,60 +24,36 @@ public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase { * Construction with non-existent field throws RuntimeException */ public void testConstructor() { - try{ - AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> + try { + AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater (AtomicIntegerFieldUpdaterTest.class, "y"); shouldThrow(); - } - catch (RuntimeException rt) {} + } catch (RuntimeException success) {} } /** * construction with field not of given type throws RuntimeException */ public void testConstructor2() { - try{ - AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> + try { + AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater (AtomicIntegerFieldUpdaterTest.class, "z"); shouldThrow(); - } - catch (RuntimeException rt) {} + } catch (RuntimeException success) {} } /** * construction with non-volatile field throws RuntimeException */ public void testConstructor3() { - try{ - AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> + try { + AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater.newUpdater (AtomicIntegerFieldUpdaterTest.class, "w"); shouldThrow(); - } - catch (RuntimeException rt) {} - } - - static class Base { - protected volatile int f = 0; - } - static class Sub1 extends Base { - AtomicIntegerFieldUpdater<Base> fUpdater - = AtomicIntegerFieldUpdater.newUpdater(Base.class, "f"); - } - static class Sub2 extends Base {} - - public void testProtectedFieldOnAnotherSubtype() { - Sub1 sub1 = new Sub1(); - Sub2 sub2 = new Sub2(); - - sub1.fUpdater.set(sub1, 1); - try { - sub1.fUpdater.set(sub2, 2); - shouldThrow(); - } - catch (RuntimeException rt) {} + } catch (RuntimeException success) {} } /** @@ -96,7 +72,24 @@ public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase { assertEquals(2,a.get(this)); a.set(this,-3); assertEquals(-3,a.get(this)); - + } + + /** + * get returns the last value lazySet by same thread + */ + public void testGetLazySet() { + AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a; + try { + a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x"); + } catch (RuntimeException ok) { + return; + } + x = 1; + assertEquals(1,a.get(this)); + a.lazySet(this,2); + assertEquals(2,a.get(this)); + a.lazySet(this,-3); + assertEquals(-3,a.get(this)); } /** @@ -114,7 +107,7 @@ public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase { assertTrue(a.compareAndSet(this,2,-4)); assertEquals(-4,a.get(this)); assertFalse(a.compareAndSet(this,-5,7)); - assertFalse((7 == a.get(this))); + assertEquals(-4,a.get(this)); assertTrue(a.compareAndSet(this,-4,7)); assertEquals(7,a.get(this)); } @@ -124,7 +117,7 @@ public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase { * compareAndSet in one thread enables another waiting for value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws Exception { x = 1; final AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest>a; try { @@ -133,25 +126,22 @@ public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase { return; } - Thread t = new Thread(new Runnable() { - public void run() { - while(!a.compareAndSet(AtomicIntegerFieldUpdaterTest.this, 2, 3)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(a.compareAndSet(this, 1, 2)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(a.get(this), 3); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!a.compareAndSet(AtomicIntegerFieldUpdaterTest.this, 2, 3)) + Thread.yield(); + }}); + + t.start(); + assertTrue(a.compareAndSet(this, 1, 2)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertEquals(a.get(this), 3); } /** * repeated weakCompareAndSet succeeds in changing value when equal - * to expected + * to expected */ public void testWeakCompareAndSet() { AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a; @@ -161,10 +151,10 @@ public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase { return; } x = 1; - while(!a.weakCompareAndSet(this,1,2)); - while(!a.weakCompareAndSet(this,2,-4)); + while (!a.weakCompareAndSet(this,1,2)); + while (!a.weakCompareAndSet(this,2,-4)); assertEquals(-4,a.get(this)); - while(!a.weakCompareAndSet(this,-4,7)); + while (!a.weakCompareAndSet(this,-4,7)); assertEquals(7,a.get(this)); } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerTest.java index a6b2a17..a2f3b4b 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.atomic.*; @@ -17,10 +17,14 @@ public class AtomicIntegerTest extends JSR166TestCase { return new TestSuite(AtomicIntegerTest.class); } + final int[] VALUES = { + Integer.MIN_VALUE, -1, 0, 1, 42, Integer.MAX_VALUE, + }; + /** * constructor initializes to given value */ - public void testConstructor(){ + public void testConstructor() { AtomicInteger ai = new AtomicInteger(1); assertEquals(1,ai.get()); } @@ -28,7 +32,7 @@ public class AtomicIntegerTest extends JSR166TestCase { /** * default constructed initializes to zero */ - public void testConstructor2(){ + public void testConstructor2() { AtomicInteger ai = new AtomicInteger(); assertEquals(0,ai.get()); } @@ -36,26 +40,37 @@ public class AtomicIntegerTest extends JSR166TestCase { /** * get returns the last value set */ - public void testGetSet(){ + public void testGetSet() { AtomicInteger ai = new AtomicInteger(1); assertEquals(1,ai.get()); ai.set(2); assertEquals(2,ai.get()); ai.set(-3); assertEquals(-3,ai.get()); - + } + + /** + * get returns the last value lazySet in same thread + */ + public void testGetLazySet() { + AtomicInteger ai = new AtomicInteger(1); + assertEquals(1,ai.get()); + ai.lazySet(2); + assertEquals(2,ai.get()); + ai.lazySet(-3); + assertEquals(-3,ai.get()); } /** * compareAndSet succeeds in changing value if equal to expected else fails */ - public void testCompareAndSet(){ + public void testCompareAndSet() { AtomicInteger ai = new AtomicInteger(1); assertTrue(ai.compareAndSet(1,2)); assertTrue(ai.compareAndSet(2,-4)); assertEquals(-4,ai.get()); assertFalse(ai.compareAndSet(-5,7)); - assertFalse((7 == ai.get())); + assertEquals(-4,ai.get()); assertTrue(ai.compareAndSet(-4,7)); assertEquals(7,ai.get()); } @@ -64,41 +79,38 @@ public class AtomicIntegerTest extends JSR166TestCase { * compareAndSet in one thread enables another waiting for value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws Exception { final AtomicInteger ai = new AtomicInteger(1); - Thread t = new Thread(new Runnable() { - public void run() { - while(!ai.compareAndSet(2, 3)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(ai.compareAndSet(1, 2)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(ai.get(), 3); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!ai.compareAndSet(2, 3)) + Thread.yield(); + }}); + + t.start(); + assertTrue(ai.compareAndSet(1, 2)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertEquals(ai.get(), 3); } /** * repeated weakCompareAndSet succeeds in changing value when equal - * to expected + * to expected */ - public void testWeakCompareAndSet(){ + public void testWeakCompareAndSet() { AtomicInteger ai = new AtomicInteger(1); - while(!ai.weakCompareAndSet(1,2)); - while(!ai.weakCompareAndSet(2,-4)); + while (!ai.weakCompareAndSet(1,2)); + while (!ai.weakCompareAndSet(2,-4)); assertEquals(-4,ai.get()); - while(!ai.weakCompareAndSet(-4,7)); + while (!ai.weakCompareAndSet(-4,7)); assertEquals(7,ai.get()); } /** * getAndSet returns previous value and sets to given value */ - public void testGetAndSet(){ + public void testGetAndSet() { AtomicInteger ai = new AtomicInteger(1); assertEquals(1,ai.getAndSet(0)); assertEquals(0,ai.getAndSet(-10)); @@ -108,7 +120,7 @@ public class AtomicIntegerTest extends JSR166TestCase { /** * getAndAdd returns previous value and adds given value */ - public void testGetAndAdd(){ + public void testGetAndAdd() { AtomicInteger ai = new AtomicInteger(1); assertEquals(1,ai.getAndAdd(2)); assertEquals(3,ai.get()); @@ -119,7 +131,7 @@ public class AtomicIntegerTest extends JSR166TestCase { /** * getAndDecrement returns previous value and decrements */ - public void testGetAndDecrement(){ + public void testGetAndDecrement() { AtomicInteger ai = new AtomicInteger(1); assertEquals(1,ai.getAndDecrement()); assertEquals(0,ai.getAndDecrement()); @@ -129,7 +141,7 @@ public class AtomicIntegerTest extends JSR166TestCase { /** * getAndIncrement returns previous value and increments */ - public void testGetAndIncrement(){ + public void testGetAndIncrement() { AtomicInteger ai = new AtomicInteger(1); assertEquals(1,ai.getAndIncrement()); assertEquals(2,ai.get()); @@ -143,7 +155,7 @@ public class AtomicIntegerTest extends JSR166TestCase { /** * addAndGet adds given value to current, and returns current value */ - public void testAddAndGet(){ + public void testAddAndGet() { AtomicInteger ai = new AtomicInteger(1); assertEquals(3,ai.addAndGet(2)); assertEquals(3,ai.get()); @@ -154,7 +166,7 @@ public class AtomicIntegerTest extends JSR166TestCase { /** * decrementAndGet decrements and returns current value */ - public void testDecrementAndGet(){ + public void testDecrementAndGet() { AtomicInteger ai = new AtomicInteger(1); assertEquals(0,ai.decrementAndGet()); assertEquals(-1,ai.decrementAndGet()); @@ -165,7 +177,7 @@ public class AtomicIntegerTest extends JSR166TestCase { /** * incrementAndGet increments and returns current value */ - public void testIncrementAndGet(){ + public void testIncrementAndGet() { AtomicInteger ai = new AtomicInteger(1); assertEquals(2,ai.incrementAndGet()); assertEquals(2,ai.get()); @@ -179,81 +191,79 @@ public class AtomicIntegerTest extends JSR166TestCase { /** * a deserialized serialized atomic holds same value */ - public void testSerialization() { + public void testSerialization() throws Exception { AtomicInteger l = new AtomicInteger(); - try { - l.set(22); - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); + l.set(22); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - AtomicInteger r = (AtomicInteger) in.readObject(); - assertEquals(l.get(), r.get()); - } catch(Exception e){ - unexpectedException(); - } + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + AtomicInteger r = (AtomicInteger) in.readObject(); + assertEquals(l.get(), r.get()); } /** * toString returns current value. - */ + */ public void testToString() { AtomicInteger ai = new AtomicInteger(); - for (int i = -12; i < 6; ++i) { - ai.set(i); - assertEquals(ai.toString(), Integer.toString(i)); + assertEquals("0", ai.toString()); + for (int x : VALUES) { + ai.set(x); + assertEquals(ai.toString(), Integer.toString(x)); } } /** * intValue returns current value. - */ + */ public void testIntValue() { AtomicInteger ai = new AtomicInteger(); - for (int i = -12; i < 6; ++i) { - ai.set(i); - assertEquals(i, ai.intValue()); + assertEquals(0, ai.intValue()); + for (int x : VALUES) { + ai.set(x); + assertEquals(x, ai.intValue()); } } - /** * longValue returns current value. - */ + */ public void testLongValue() { AtomicInteger ai = new AtomicInteger(); - for (int i = -12; i < 6; ++i) { - ai.set(i); - assertEquals((long)i, ai.longValue()); + assertEquals(0L, ai.longValue()); + for (int x : VALUES) { + ai.set(x); + assertEquals((long)x, ai.longValue()); } } /** * floatValue returns current value. - */ + */ public void testFloatValue() { AtomicInteger ai = new AtomicInteger(); - for (int i = -12; i < 6; ++i) { - ai.set(i); - assertEquals((float)i, ai.floatValue()); + assertEquals(0.0f, ai.floatValue()); + for (int x : VALUES) { + ai.set(x); + assertEquals((float)x, ai.floatValue()); } } /** * doubleValue returns current value. - */ + */ public void testDoubleValue() { AtomicInteger ai = new AtomicInteger(); - for (int i = -12; i < 6; ++i) { - ai.set(i); - assertEquals((double)i, ai.doubleValue()); + assertEquals(0.0d, ai.doubleValue()); + for (int x : VALUES) { + ai.set(x); + assertEquals((double)x, ai.doubleValue()); } } - - } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongArrayTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongArrayTest.java index 262d273..88e0984 100644 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongArrayTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongArrayTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.atomic.*; @@ -21,9 +21,9 @@ public class AtomicLongArrayTest extends JSR166TestCase { /** * constructor creates array of given size with all elements zero */ - public void testConstructor(){ + public void testConstructor() { AtomicLongArray ai = new AtomicLongArray(SIZE); - for (int i = 0; i < SIZE; ++i) + for (int i = 0; i < SIZE; ++i) assertEquals(0,ai.get(i)); } @@ -34,10 +34,8 @@ public class AtomicLongArrayTest extends JSR166TestCase { try { long[] a = null; AtomicLongArray ai = new AtomicLongArray(a); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + shouldThrow(); + } catch (NullPointerException success) {} } /** @@ -47,38 +45,42 @@ public class AtomicLongArrayTest extends JSR166TestCase { long[] a = { 17L, 3L, -42L, 99L, -7L}; AtomicLongArray ai = new AtomicLongArray(a); assertEquals(a.length, ai.length()); - for (int i = 0; i < a.length; ++i) + for (int i = 0; i < a.length; ++i) assertEquals(a[i], ai.get(i)); } /** * get and set for out of bound indices throw IndexOutOfBoundsException */ - public void testIndexing(){ + public void testIndexing() { AtomicLongArray ai = new AtomicLongArray(SIZE); try { ai.get(SIZE); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } try { ai.get(-1); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } try { ai.set(SIZE, 0); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } try { ai.set(-1, 0); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } } /** * get returns the last value set at index */ - public void testGetSet(){ - AtomicLongArray ai = new AtomicLongArray(SIZE); + public void testGetSet() { + AtomicLongArray ai = new AtomicLongArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(1,ai.get(i)); @@ -90,17 +92,32 @@ public class AtomicLongArrayTest extends JSR166TestCase { } /** + * get returns the last value lazySet at index by same thread + */ + public void testGetLazySet() { + AtomicLongArray ai = new AtomicLongArray(SIZE); + for (int i = 0; i < SIZE; ++i) { + ai.lazySet(i, 1); + assertEquals(1,ai.get(i)); + ai.lazySet(i, 2); + assertEquals(2,ai.get(i)); + ai.lazySet(i, -3); + assertEquals(-3,ai.get(i)); + } + } + + /** * compareAndSet succeeds in changing value if equal to expected else fails */ - public void testCompareAndSet(){ - AtomicLongArray ai = new AtomicLongArray(SIZE); + public void testCompareAndSet() { + AtomicLongArray ai = new AtomicLongArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertTrue(ai.compareAndSet(i, 1,2)); assertTrue(ai.compareAndSet(i, 2,-4)); assertEquals(-4,ai.get(i)); assertFalse(ai.compareAndSet(i, -5,7)); - assertFalse((7 == ai.get(i))); + assertEquals(-4,ai.get(i)); assertTrue(ai.compareAndSet(i, -4,7)); assertEquals(7,ai.get(i)); } @@ -110,37 +127,34 @@ public class AtomicLongArrayTest extends JSR166TestCase { * compareAndSet in one thread enables another waiting for value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws InterruptedException { final AtomicLongArray a = new AtomicLongArray(1); a.set(0, 1); - Thread t = new Thread(new Runnable() { - public void run() { - while(!a.compareAndSet(0, 2, 3)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(a.compareAndSet(0, 1, 2)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(a.get(0), 3); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!a.compareAndSet(0, 2, 3)) + Thread.yield(); + }}); + + t.start(); + assertTrue(a.compareAndSet(0, 1, 2)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertEquals(a.get(0), 3); } /** * repeated weakCompareAndSet succeeds in changing value when equal - * to expected + * to expected */ - public void testWeakCompareAndSet(){ - AtomicLongArray ai = new AtomicLongArray(SIZE); + public void testWeakCompareAndSet() { + AtomicLongArray ai = new AtomicLongArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); - while(!ai.weakCompareAndSet(i, 1,2)); - while(!ai.weakCompareAndSet(i, 2,-4)); + while (!ai.weakCompareAndSet(i, 1,2)); + while (!ai.weakCompareAndSet(i, 2,-4)); assertEquals(-4,ai.get(i)); - while(!ai.weakCompareAndSet(i, -4,7)); + while (!ai.weakCompareAndSet(i, -4,7)); assertEquals(7,ai.get(i)); } } @@ -148,8 +162,8 @@ public class AtomicLongArrayTest extends JSR166TestCase { /** * getAndSet returns previous value and sets to given value at given index */ - public void testGetAndSet(){ - AtomicLongArray ai = new AtomicLongArray(SIZE); + public void testGetAndSet() { + AtomicLongArray ai = new AtomicLongArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(1,ai.getAndSet(i,0)); @@ -161,8 +175,8 @@ public class AtomicLongArrayTest extends JSR166TestCase { /** * getAndAdd returns previous value and adds given value */ - public void testGetAndAdd(){ - AtomicLongArray ai = new AtomicLongArray(SIZE); + public void testGetAndAdd() { + AtomicLongArray ai = new AtomicLongArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(1,ai.getAndAdd(i,2)); @@ -175,8 +189,8 @@ public class AtomicLongArrayTest extends JSR166TestCase { /** * getAndDecrement returns previous value and decrements */ - public void testGetAndDecrement(){ - AtomicLongArray ai = new AtomicLongArray(SIZE); + public void testGetAndDecrement() { + AtomicLongArray ai = new AtomicLongArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(1,ai.getAndDecrement(i)); @@ -188,8 +202,8 @@ public class AtomicLongArrayTest extends JSR166TestCase { /** * getAndIncrement returns previous value and increments */ - public void testGetAndIncrement(){ - AtomicLongArray ai = new AtomicLongArray(SIZE); + public void testGetAndIncrement() { + AtomicLongArray ai = new AtomicLongArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(1,ai.getAndIncrement(i)); @@ -206,7 +220,7 @@ public class AtomicLongArrayTest extends JSR166TestCase { * addAndGet adds given value to current, and returns current value */ public void testAddAndGet() { - AtomicLongArray ai = new AtomicLongArray(SIZE); + AtomicLongArray ai = new AtomicLongArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(3,ai.addAndGet(i,2)); @@ -219,8 +233,8 @@ public class AtomicLongArrayTest extends JSR166TestCase { /** * decrementAndGet decrements and returns current value */ - public void testDecrementAndGet(){ - AtomicLongArray ai = new AtomicLongArray(SIZE); + public void testDecrementAndGet() { + AtomicLongArray ai = new AtomicLongArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(0,ai.decrementAndGet(i)); @@ -234,7 +248,7 @@ public class AtomicLongArrayTest extends JSR166TestCase { * incrementAndGet increments and returns current value */ public void testIncrementAndGet() { - AtomicLongArray ai = new AtomicLongArray(SIZE); + AtomicLongArray ai = new AtomicLongArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, 1); assertEquals(2,ai.incrementAndGet(i)); @@ -248,7 +262,7 @@ public class AtomicLongArrayTest extends JSR166TestCase { } static final long COUNTDOWN = 100000; - + class Counter implements Runnable { final AtomicLongArray ai; volatile long counts; @@ -275,54 +289,45 @@ public class AtomicLongArrayTest extends JSR166TestCase { * Multiple threads using same array of counters successfully * update a number of times equal to total count */ - public void testCountingInMultipleThreads() { - try { - final AtomicLongArray ai = new AtomicLongArray(SIZE); - for (int i = 0; i < SIZE; ++i) - ai.set(i, COUNTDOWN); - Counter c1 = new Counter(ai); - Counter c2 = new Counter(ai); - Thread t1 = new Thread(c1); - Thread t2 = new Thread(c2); - t1.start(); - t2.start(); - t1.join(); - t2.join(); - assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN); - } - catch(InterruptedException ie) { - unexpectedException(); - } + public void testCountingInMultipleThreads() throws InterruptedException { + final AtomicLongArray ai = new AtomicLongArray(SIZE); + for (int i = 0; i < SIZE; ++i) + ai.set(i, COUNTDOWN); + Counter c1 = new Counter(ai); + Counter c2 = new Counter(ai); + Thread t1 = new Thread(c1); + Thread t2 = new Thread(c2); + t1.start(); + t2.start(); + t1.join(); + t2.join(); + assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN); } /** * a deserialized serialized array holds same values */ - public void testSerialization() { - AtomicLongArray l = new AtomicLongArray(SIZE); - for (int i = 0; i < SIZE; ++i) + public void testSerialization() throws Exception { + AtomicLongArray l = new AtomicLongArray(SIZE); + for (int i = 0; i < SIZE; ++i) l.set(i, -i); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - AtomicLongArray r = (AtomicLongArray) in.readObject(); - for (int i = 0; i < SIZE; ++i) { - assertEquals(l.get(i), r.get(i)); - } - } catch(Exception e){ - unexpectedException(); + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + AtomicLongArray r = (AtomicLongArray) in.readObject(); + for (int i = 0; i < SIZE; ++i) { + assertEquals(l.get(i), r.get(i)); } } /** * toString returns current value. - */ + */ public void testToString() { long[] a = { 17, 3, -42, 99, -7}; AtomicLongArray ai = new AtomicLongArray(a); diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongFieldUpdaterTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongFieldUpdaterTest.java index bac25dc..491baf4 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongFieldUpdaterTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongFieldUpdaterTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import java.util.concurrent.atomic.*; import junit.framework.*; @@ -24,68 +24,61 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { /** * Construction with non-existent field throws RuntimeException */ - public void testConstructor(){ - try{ + public void testConstructor() { + try { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a = AtomicLongFieldUpdater.newUpdater (AtomicLongFieldUpdaterTest.class, "y"); shouldThrow(); - } - catch (RuntimeException rt) {} + } catch (RuntimeException success) {} } /** * construction with field not of given type throws RuntimeException */ - public void testConstructor2(){ - try{ + public void testConstructor2() { + try { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a = AtomicLongFieldUpdater.newUpdater (AtomicLongFieldUpdaterTest.class, "z"); shouldThrow(); - } - catch (RuntimeException rt) {} + } catch (RuntimeException success) {} } /** * construction with non-volatile field throws RuntimeException */ - public void testConstructor3(){ - try{ + public void testConstructor3() { + try { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a = AtomicLongFieldUpdater.newUpdater (AtomicLongFieldUpdaterTest.class, "w"); shouldThrow(); - } - - catch (RuntimeException rt) {} + } catch (RuntimeException success) {} } - static class Base { - protected volatile long f = 0; - } - static class Sub1 extends Base { - AtomicLongFieldUpdater<Base> fUpdater - = AtomicLongFieldUpdater.newUpdater(Base.class, "f"); - } - static class Sub2 extends Base {} - - public void testProtectedFieldOnAnotherSubtype() { - Sub1 sub1 = new Sub1(); - Sub2 sub2 = new Sub2(); - - sub1.fUpdater.set(sub1, 1); + /** + * get returns the last value set or assigned + */ + public void testGetSet() { + AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; try { - sub1.fUpdater.set(sub2, 2); - shouldThrow(); + a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x"); + } catch (RuntimeException ok) { + return; } - catch (RuntimeException rt) {} + x = 1; + assertEquals(1,a.get(this)); + a.set(this,2); + assertEquals(2,a.get(this)); + a.set(this,-3); + assertEquals(-3,a.get(this)); } /** - * get returns the last value set or assigned + * get returns the last value lazySet by same thread */ - public void testGetSet(){ + public void testGetLazySet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; try { a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x"); @@ -93,17 +86,18 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { return; } x = 1; - assertEquals(1,a.get(this)); - a.set(this,2); - assertEquals(2,a.get(this)); - a.set(this,-3); - assertEquals(-3,a.get(this)); - + assertEquals(1,a.get(this)); + a.lazySet(this,2); + assertEquals(2,a.get(this)); + a.lazySet(this,-3); + assertEquals(-3,a.get(this)); } + + /** * compareAndSet succeeds in changing value if equal to expected else fails */ - public void testCompareAndSet(){ + public void testCompareAndSet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; try { a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x"); @@ -115,7 +109,7 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { assertTrue(a.compareAndSet(this,2,-4)); assertEquals(-4,a.get(this)); assertFalse(a.compareAndSet(this,-5,7)); - assertFalse((7 == a.get(this))); + assertEquals(-4,a.get(this)); assertTrue(a.compareAndSet(this,-4,7)); assertEquals(7,a.get(this)); } @@ -125,7 +119,7 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { * compareAndSet in one thread enables another waiting for value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws Exception { x = 1; final AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>a; try { @@ -134,27 +128,24 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { return; } - Thread t = new Thread(new Runnable() { - public void run() { - while(!a.compareAndSet(AtomicLongFieldUpdaterTest.this, 2, 3)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(a.compareAndSet(this, 1, 2)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(a.get(this), 3); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!a.compareAndSet(AtomicLongFieldUpdaterTest.this, 2, 3)) + Thread.yield(); + }}); + + t.start(); + assertTrue(a.compareAndSet(this, 1, 2)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertEquals(a.get(this), 3); } /** * repeated weakCompareAndSet succeeds in changing value when equal * to expected */ - public void testWeakCompareAndSet(){ + public void testWeakCompareAndSet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; try { a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x"); @@ -162,17 +153,17 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { return; } x = 1; - while(!a.weakCompareAndSet(this,1,2)); - while(!a.weakCompareAndSet(this,2,-4)); + while (!a.weakCompareAndSet(this,1,2)); + while (!a.weakCompareAndSet(this,2,-4)); assertEquals(-4,a.get(this)); - while(!a.weakCompareAndSet(this,-4,7)); + while (!a.weakCompareAndSet(this,-4,7)); assertEquals(7,a.get(this)); } /** * getAndSet returns previous value and sets to given value */ - public void testGetAndSet(){ + public void testGetAndSet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; try { a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x"); @@ -188,7 +179,7 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { /** * getAndAdd returns previous value and adds given value */ - public void testGetAndAdd(){ + public void testGetAndAdd() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; try { a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x"); @@ -205,7 +196,7 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { /** * getAndDecrement returns previous value and decrements */ - public void testGetAndDecrement(){ + public void testGetAndDecrement() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; try { a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x"); @@ -221,7 +212,7 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { /** * getAndIncrement returns previous value and increments */ - public void testGetAndIncrement(){ + public void testGetAndIncrement() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; try { a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x"); @@ -241,7 +232,7 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { /** * addAndGet adds given value to current, and returns current value */ - public void testAddAndGet(){ + public void testAddAndGet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; try { a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x"); @@ -258,7 +249,7 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { /** * decrementAndGet decrements and returns current value */ - public void testDecrementAndGet(){ + public void testDecrementAndGet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; try { a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x"); @@ -275,7 +266,7 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase { /** * incrementAndGet increments and returns current value */ - public void testIncrementAndGet(){ + public void testIncrementAndGet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; try { a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x"); diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongTest.java index f4805bf..e73e86e 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.atomic.*; @@ -17,10 +17,16 @@ public class AtomicLongTest extends JSR166TestCase { return new TestSuite(AtomicLongTest.class); } + final long[] VALUES = { + Long.MIN_VALUE, + Integer.MIN_VALUE, -1, 0, 1, 42, Integer.MAX_VALUE, + Long.MAX_VALUE, + }; + /** * constructor initializes to given value */ - public void testConstructor(){ + public void testConstructor() { AtomicLong ai = new AtomicLong(1); assertEquals(1,ai.get()); } @@ -28,7 +34,7 @@ public class AtomicLongTest extends JSR166TestCase { /** * default constructed initializes to zero */ - public void testConstructor2(){ + public void testConstructor2() { AtomicLong ai = new AtomicLong(); assertEquals(0,ai.get()); } @@ -36,26 +42,37 @@ public class AtomicLongTest extends JSR166TestCase { /** * get returns the last value set */ - public void testGetSet(){ + public void testGetSet() { AtomicLong ai = new AtomicLong(1); assertEquals(1,ai.get()); ai.set(2); assertEquals(2,ai.get()); ai.set(-3); assertEquals(-3,ai.get()); - + } + + /** + * get returns the last value lazySet in same thread + */ + public void testGetLazySet() { + AtomicLong ai = new AtomicLong(1); + assertEquals(1,ai.get()); + ai.lazySet(2); + assertEquals(2,ai.get()); + ai.lazySet(-3); + assertEquals(-3,ai.get()); } /** * compareAndSet succeeds in changing value if equal to expected else fails */ - public void testCompareAndSet(){ + public void testCompareAndSet() { AtomicLong ai = new AtomicLong(1); assertTrue(ai.compareAndSet(1,2)); assertTrue(ai.compareAndSet(2,-4)); assertEquals(-4,ai.get()); assertFalse(ai.compareAndSet(-5,7)); - assertFalse((7 == ai.get())); + assertEquals(-4,ai.get()); assertTrue(ai.compareAndSet(-4,7)); assertEquals(7,ai.get()); } @@ -64,41 +81,38 @@ public class AtomicLongTest extends JSR166TestCase { * compareAndSet in one thread enables another waiting for value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws Exception { final AtomicLong ai = new AtomicLong(1); - Thread t = new Thread(new Runnable() { - public void run() { - while(!ai.compareAndSet(2, 3)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(ai.compareAndSet(1, 2)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(ai.get(), 3); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!ai.compareAndSet(2, 3)) + Thread.yield(); + }}); + + t.start(); + assertTrue(ai.compareAndSet(1, 2)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertEquals(ai.get(), 3); } /** * repeated weakCompareAndSet succeeds in changing value when equal - * to expected + * to expected */ - public void testWeakCompareAndSet(){ + public void testWeakCompareAndSet() { AtomicLong ai = new AtomicLong(1); - while(!ai.weakCompareAndSet(1,2)); - while(!ai.weakCompareAndSet(2,-4)); + while (!ai.weakCompareAndSet(1,2)); + while (!ai.weakCompareAndSet(2,-4)); assertEquals(-4,ai.get()); - while(!ai.weakCompareAndSet(-4,7)); + while (!ai.weakCompareAndSet(-4,7)); assertEquals(7,ai.get()); } /** * getAndSet returns previous value and sets to given value */ - public void testGetAndSet(){ + public void testGetAndSet() { AtomicLong ai = new AtomicLong(1); assertEquals(1,ai.getAndSet(0)); assertEquals(0,ai.getAndSet(-10)); @@ -108,7 +122,7 @@ public class AtomicLongTest extends JSR166TestCase { /** * getAndAdd returns previous value and adds given value */ - public void testGetAndAdd(){ + public void testGetAndAdd() { AtomicLong ai = new AtomicLong(1); assertEquals(1,ai.getAndAdd(2)); assertEquals(3,ai.get()); @@ -119,7 +133,7 @@ public class AtomicLongTest extends JSR166TestCase { /** * getAndDecrement returns previous value and decrements */ - public void testGetAndDecrement(){ + public void testGetAndDecrement() { AtomicLong ai = new AtomicLong(1); assertEquals(1,ai.getAndDecrement()); assertEquals(0,ai.getAndDecrement()); @@ -129,7 +143,7 @@ public class AtomicLongTest extends JSR166TestCase { /** * getAndIncrement returns previous value and increments */ - public void testGetAndIncrement(){ + public void testGetAndIncrement() { AtomicLong ai = new AtomicLong(1); assertEquals(1,ai.getAndIncrement()); assertEquals(2,ai.get()); @@ -143,7 +157,7 @@ public class AtomicLongTest extends JSR166TestCase { /** * addAndGet adds given value to current, and returns current value */ - public void testAddAndGet(){ + public void testAddAndGet() { AtomicLong ai = new AtomicLong(1); assertEquals(3,ai.addAndGet(2)); assertEquals(3,ai.get()); @@ -154,7 +168,7 @@ public class AtomicLongTest extends JSR166TestCase { /** * decrementAndGet decrements and returns current value */ - public void testDecrementAndGet(){ + public void testDecrementAndGet() { AtomicLong ai = new AtomicLong(1); assertEquals(0,ai.decrementAndGet()); assertEquals(-1,ai.decrementAndGet()); @@ -165,7 +179,7 @@ public class AtomicLongTest extends JSR166TestCase { /** * incrementAndGet increments and returns current value */ - public void testIncrementAndGet(){ + public void testIncrementAndGet() { AtomicLong ai = new AtomicLong(1); assertEquals(2,ai.incrementAndGet()); assertEquals(2,ai.get()); @@ -179,68 +193,79 @@ public class AtomicLongTest extends JSR166TestCase { /** * a deserialized serialized atomic holds same value */ - public void testSerialization() { + public void testSerialization() throws Exception { AtomicLong l = new AtomicLong(); - try { - l.set(-22); - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - AtomicLong r = (AtomicLong) in.readObject(); - assertEquals(l.get(), r.get()); - } catch(Exception e){ - unexpectedException(); - } + l.set(-22); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + AtomicLong r = (AtomicLong) in.readObject(); + assertEquals(l.get(), r.get()); } /** * toString returns current value. - */ + */ public void testToString() { AtomicLong ai = new AtomicLong(); - for (long i = -12; i < 6; ++i) { + assertEquals("0", ai.toString()); + for (long i : VALUES) { ai.set(i); assertEquals(ai.toString(), Long.toString(i)); } } /** + * intValue returns current value. + */ + public void testIntValue() { + AtomicLong ai = new AtomicLong(); + assertEquals(0, ai.intValue()); + for (long x : VALUES) { + ai.set(x); + assertEquals((int)x, ai.intValue()); + } + } + + /** * longValue returns current value. - */ + */ public void testLongValue() { AtomicLong ai = new AtomicLong(); - for (int i = -12; i < 6; ++i) { - ai.set(i); - assertEquals((long)i, ai.longValue()); + assertEquals(0L, ai.longValue()); + for (long x : VALUES) { + ai.set(x); + assertEquals((long)x, ai.longValue()); } } /** * floatValue returns current value. - */ + */ public void testFloatValue() { AtomicLong ai = new AtomicLong(); - for (int i = -12; i < 6; ++i) { - ai.set(i); - assertEquals((float)i, ai.floatValue()); + assertEquals(0.0f, ai.floatValue()); + for (long x : VALUES) { + ai.set(x); + assertEquals((float)x, ai.floatValue()); } } /** * doubleValue returns current value. - */ + */ public void testDoubleValue() { AtomicLong ai = new AtomicLong(); - for (int i = -12; i < 6; ++i) { - ai.set(i); - assertEquals((double)i, ai.doubleValue()); + assertEquals(0.0d, ai.doubleValue()); + for (long x : VALUES) { + ai.set(x); + assertEquals((double)x, ai.doubleValue()); } } - } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicMarkableReferenceTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicMarkableReferenceTest.java index 7857dde..72a2337 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicMarkableReferenceTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicMarkableReferenceTest.java @@ -2,65 +2,64 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.atomic.*; -public class AtomicMarkableReferenceTest extends JSR166TestCase{ +public class AtomicMarkableReferenceTest extends JSR166TestCase { public static Test suite() { return new TestSuite(AtomicMarkableReferenceTest.class); } - + /** * constructor initializes to given reference and mark */ - public void testConstructor(){ + public void testConstructor() { AtomicMarkableReference ai = new AtomicMarkableReference(one, false); - assertEquals(one,ai.getReference()); + assertSame(one,ai.getReference()); assertFalse(ai.isMarked()); AtomicMarkableReference a2 = new AtomicMarkableReference(null, true); assertNull(a2.getReference()); assertTrue(a2.isMarked()); - } /** * get returns the last values of reference and mark set */ - public void testGetSet(){ + public void testGetSet() { boolean[] mark = new boolean[1]; AtomicMarkableReference ai = new AtomicMarkableReference(one, false); - assertEquals(one,ai.getReference()); + assertSame(one,ai.getReference()); assertFalse(ai.isMarked()); - assertEquals(one, ai.get(mark)); + assertSame(one, ai.get(mark)); assertFalse(mark[0]); ai.set(two, false); - assertEquals(two,ai.getReference()); + assertSame(two,ai.getReference()); assertFalse(ai.isMarked()); - assertEquals(two, ai.get(mark)); + assertSame(two, ai.get(mark)); assertFalse(mark[0]); ai.set(one, true); - assertEquals(one,ai.getReference()); + assertSame(one,ai.getReference()); assertTrue(ai.isMarked()); - assertEquals(one, ai.get(mark)); + assertSame(one, ai.get(mark)); assertTrue(mark[0]); } /** * attemptMark succeeds in single thread */ - public void testAttemptMark(){ + public void testAttemptMark() { boolean[] mark = new boolean[1]; AtomicMarkableReference ai = new AtomicMarkableReference(one, false); assertFalse(ai.isMarked()); assertTrue(ai.attemptMark(one, true)); assertTrue(ai.isMarked()); - assertEquals(one, ai.get(mark)); + assertSame(one, ai.get(mark)); assertTrue(mark[0]); } @@ -68,23 +67,23 @@ public class AtomicMarkableReferenceTest extends JSR166TestCase{ * compareAndSet succeeds in changing values if equal to expected reference * and mark else fails */ - public void testCompareAndSet(){ + public void testCompareAndSet() { boolean[] mark = new boolean[1]; AtomicMarkableReference ai = new AtomicMarkableReference(one, false); - assertEquals(one, ai.get(mark)); + assertSame(one, ai.get(mark)); assertFalse(ai.isMarked()); assertFalse(mark[0]); assertTrue(ai.compareAndSet(one, two, false, false)); - assertEquals(two, ai.get(mark)); + assertSame(two, ai.get(mark)); assertFalse(mark[0]); assertTrue(ai.compareAndSet(two, m3, false, true)); - assertEquals(m3, ai.get(mark)); + assertSame(m3, ai.get(mark)); assertTrue(mark[0]); assertFalse(ai.compareAndSet(two, m3, true, true)); - assertEquals(m3, ai.get(mark)); + assertSame(m3, ai.get(mark)); assertTrue(mark[0]); } @@ -92,65 +91,59 @@ public class AtomicMarkableReferenceTest extends JSR166TestCase{ * compareAndSet in one thread enables another waiting for reference value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws Exception { final AtomicMarkableReference ai = new AtomicMarkableReference(one, false); - Thread t = new Thread(new Runnable() { - public void run() { - while(!ai.compareAndSet(two, three, false, false)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(ai.compareAndSet(one, two, false, false)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(ai.getReference(), three); - assertFalse(ai.isMarked()); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!ai.compareAndSet(two, three, false, false)) + Thread.yield(); + }}); + + t.start(); + assertTrue(ai.compareAndSet(one, two, false, false)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertSame(ai.getReference(), three); + assertFalse(ai.isMarked()); } /** * compareAndSet in one thread enables another waiting for mark value * to succeed */ - public void testCompareAndSetInMultipleThreads2() { + public void testCompareAndSetInMultipleThreads2() throws Exception { final AtomicMarkableReference ai = new AtomicMarkableReference(one, false); - Thread t = new Thread(new Runnable() { - public void run() { - while(!ai.compareAndSet(one, one, true, false)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(ai.compareAndSet(one, one, false, true)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(ai.getReference(), one); - assertFalse(ai.isMarked()); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!ai.compareAndSet(one, one, true, false)) + Thread.yield(); + }}); + + t.start(); + assertTrue(ai.compareAndSet(one, one, false, true)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertSame(ai.getReference(), one); + assertFalse(ai.isMarked()); } /** * repeated weakCompareAndSet succeeds in changing values when equal - * to expected + * to expected */ - public void testWeakCompareAndSet(){ + public void testWeakCompareAndSet() { boolean[] mark = new boolean[1]; AtomicMarkableReference ai = new AtomicMarkableReference(one, false); - assertEquals(one, ai.get(mark)); + assertSame(one, ai.get(mark)); assertFalse(ai.isMarked()); assertFalse(mark[0]); - while(!ai.weakCompareAndSet(one, two, false, false)); - assertEquals(two, ai.get(mark)); + while (!ai.weakCompareAndSet(one, two, false, false)); + assertSame(two, ai.get(mark)); assertFalse(mark[0]); - while(!ai.weakCompareAndSet(two, m3, false, true)); - assertEquals(m3, ai.get(mark)); + while (!ai.weakCompareAndSet(two, m3, false, true)); + assertSame(m3, ai.get(mark)); assertTrue(mark[0]); } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceArrayTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceArrayTest.java index 81248cc..25f8474 100644 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceArrayTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceArrayTest.java @@ -2,19 +2,18 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.atomic.*; import java.io.*; import java.util.*; -public class AtomicReferenceArrayTest extends JSR166TestCase -{ +public class AtomicReferenceArrayTest extends JSR166TestCase { public static Test suite() { return new TestSuite(AtomicReferenceArrayTest.class); } @@ -22,7 +21,7 @@ public class AtomicReferenceArrayTest extends JSR166TestCase /** * constructor creates array of given size with all elements null */ - public void testConstructor(){ + public void testConstructor() { AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(SIZE); for (int i = 0; i < SIZE; ++i) { assertNull(ai.get(i)); @@ -36,10 +35,8 @@ public class AtomicReferenceArrayTest extends JSR166TestCase try { Integer[] a = null; AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(a); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + shouldThrow(); + } catch (NullPointerException success) {} } /** @@ -49,7 +46,7 @@ public class AtomicReferenceArrayTest extends JSR166TestCase Integer[] a = { two, one, three, four, seven}; AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(a); assertEquals(a.length, ai.length()); - for (int i = 0; i < a.length; ++i) + for (int i = 0; i < a.length; ++i) assertEquals(a[i], ai.get(i)); } @@ -57,55 +54,74 @@ public class AtomicReferenceArrayTest extends JSR166TestCase /** * get and set for out of bound indices throw IndexOutOfBoundsException */ - public void testIndexing(){ + public void testIndexing() { AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(SIZE); try { ai.get(SIZE); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } try { ai.get(-1); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } try { ai.set(SIZE, null); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } try { ai.set(-1, null); - } catch(IndexOutOfBoundsException success){ + shouldThrow(); + } catch (IndexOutOfBoundsException success) { } } /** * get returns the last value set at index */ - public void testGetSet(){ - AtomicReferenceArray ai = new AtomicReferenceArray(SIZE); + public void testGetSet() { + AtomicReferenceArray ai = new AtomicReferenceArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, one); - assertEquals(one,ai.get(i)); + assertSame(one,ai.get(i)); ai.set(i, two); - assertEquals(two,ai.get(i)); + assertSame(two,ai.get(i)); ai.set(i, m3); - assertEquals(m3,ai.get(i)); + assertSame(m3,ai.get(i)); + } + } + + /** + * get returns the last value lazySet at index by same thread + */ + public void testGetLazySet() { + AtomicReferenceArray ai = new AtomicReferenceArray(SIZE); + for (int i = 0; i < SIZE; ++i) { + ai.lazySet(i, one); + assertSame(one,ai.get(i)); + ai.lazySet(i, two); + assertSame(two,ai.get(i)); + ai.lazySet(i, m3); + assertSame(m3,ai.get(i)); } } /** * compareAndSet succeeds in changing value if equal to expected else fails */ - public void testCompareAndSet(){ - AtomicReferenceArray ai = new AtomicReferenceArray(SIZE); + public void testCompareAndSet() { + AtomicReferenceArray ai = new AtomicReferenceArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, one); assertTrue(ai.compareAndSet(i, one,two)); assertTrue(ai.compareAndSet(i, two,m4)); - assertEquals(m4,ai.get(i)); + assertSame(m4,ai.get(i)); assertFalse(ai.compareAndSet(i, m5,seven)); - assertFalse((seven.equals(ai.get(i)))); + assertSame(m4,ai.get(i)); assertTrue(ai.compareAndSet(i, m4,seven)); - assertEquals(seven,ai.get(i)); + assertSame(seven,ai.get(i)); } } @@ -113,85 +129,78 @@ public class AtomicReferenceArrayTest extends JSR166TestCase * compareAndSet in one thread enables another waiting for value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws InterruptedException { final AtomicReferenceArray a = new AtomicReferenceArray(1); a.set(0, one); - Thread t = new Thread(new Runnable() { - public void run() { - while(!a.compareAndSet(0, two, three)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(a.compareAndSet(0, one, two)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(a.get(0), three); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!a.compareAndSet(0, two, three)) + Thread.yield(); + }}); + + t.start(); + assertTrue(a.compareAndSet(0, one, two)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertSame(a.get(0), three); } /** * repeated weakCompareAndSet succeeds in changing value when equal - * to expected + * to expected */ - public void testWeakCompareAndSet(){ - AtomicReferenceArray ai = new AtomicReferenceArray(SIZE); + public void testWeakCompareAndSet() { + AtomicReferenceArray ai = new AtomicReferenceArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, one); - while(!ai.weakCompareAndSet(i, one,two)); - while(!ai.weakCompareAndSet(i, two,m4)); - assertEquals(m4,ai.get(i)); - while(!ai.weakCompareAndSet(i, m4,seven)); - assertEquals(seven,ai.get(i)); + while (!ai.weakCompareAndSet(i, one,two)); + while (!ai.weakCompareAndSet(i, two,m4)); + assertSame(m4,ai.get(i)); + while (!ai.weakCompareAndSet(i, m4,seven)); + assertSame(seven,ai.get(i)); } } /** * getAndSet returns previous value and sets to given value at given index */ - public void testGetAndSet(){ - AtomicReferenceArray ai = new AtomicReferenceArray(SIZE); + public void testGetAndSet() { + AtomicReferenceArray ai = new AtomicReferenceArray(SIZE); for (int i = 0; i < SIZE; ++i) { ai.set(i, one); - assertEquals(one,ai.getAndSet(i,zero)); - assertEquals(0,ai.getAndSet(i,m10)); - assertEquals(m10,ai.getAndSet(i,one)); + assertSame(one,ai.getAndSet(i,zero)); + assertSame(zero,ai.getAndSet(i,m10)); + assertSame(m10,ai.getAndSet(i,one)); } } /** * a deserialized serialized array holds same values */ - public void testSerialization() { - AtomicReferenceArray l = new AtomicReferenceArray(SIZE); + public void testSerialization() throws Exception { + AtomicReferenceArray l = new AtomicReferenceArray(SIZE); for (int i = 0; i < SIZE; ++i) { l.set(i, new Integer(-i)); } - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - AtomicReferenceArray r = (AtomicReferenceArray) in.readObject(); - assertEquals(l.length(), r.length()); - for (int i = 0; i < SIZE; ++i) { - assertEquals(r.get(i), l.get(i)); - } - } catch(Exception e){ - unexpectedException(); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + AtomicReferenceArray r = (AtomicReferenceArray) in.readObject(); + assertEquals(l.length(), r.length()); + for (int i = 0; i < SIZE; ++i) { + assertEquals(r.get(i), l.get(i)); } } /** * toString returns current value. - */ + */ public void testToString() { Integer[] a = { two, one, three, four, seven}; AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(a); diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceFieldUpdaterTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceFieldUpdaterTest.java index 7f71781..78c321e 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceFieldUpdaterTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceFieldUpdaterTest.java @@ -2,17 +2,17 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import java.util.concurrent.atomic.*; import junit.framework.*; import java.util.*; -public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase{ +public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase { volatile Integer x = null; Object z; Integer w; @@ -24,68 +24,62 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase{ /** * Construction with non-existent field throws RuntimeException */ - public void testConstructor(){ - try{ + public void testConstructor() { + try { AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a = AtomicReferenceFieldUpdater.newUpdater (AtomicReferenceFieldUpdaterTest.class, Integer.class, "y"); shouldThrow(); - } - catch (RuntimeException rt) {} + } catch (RuntimeException success) {} } /** * construction with field not of given type throws RuntimeException */ - public void testConstructor2(){ - try{ + public void testConstructor2() { + try { AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a = AtomicReferenceFieldUpdater.newUpdater (AtomicReferenceFieldUpdaterTest.class, Integer.class, "z"); shouldThrow(); - } - catch (RuntimeException rt) {} + } catch (RuntimeException success) {} } /** * Constructor with non-volatile field throws exception */ - public void testConstructor3(){ - try{ + public void testConstructor3() { + try { AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a = AtomicReferenceFieldUpdater.newUpdater (AtomicReferenceFieldUpdaterTest.class, Integer.class, "w"); shouldThrow(); - } - catch (RuntimeException rt) {} + } catch (RuntimeException success) {} } - static class Base { - protected volatile Object f = null; - } - static class Sub1 extends Base { - AtomicReferenceFieldUpdater<Base, Object> fUpdater - = AtomicReferenceFieldUpdater.newUpdater(Base.class, Object.class, "f"); - } - static class Sub2 extends Base {} - - public void testProtectedFieldOnAnotherSubtype() { - Sub1 sub1 = new Sub1(); - Sub2 sub2 = new Sub2(); - - sub1.fUpdater.set(sub1, "f"); + /** + * get returns the last value set or assigned + */ + public void testGetSet() { + AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a; try { - sub1.fUpdater.set(sub2, "g"); - shouldThrow(); + a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x"); + } catch (RuntimeException ok) { + return; } - catch (RuntimeException rt) {} + x = one; + assertSame(one,a.get(this)); + a.set(this,two); + assertSame(two,a.get(this)); + a.set(this,m3); + assertSame(m3,a.get(this)); } /** - * get returns the last value set or assigned + * get returns the last value lazySet by same thread */ - public void testGetSet(){ + public void testGetLazySet() { AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a; try { a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x"); @@ -93,16 +87,17 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase{ return; } x = one; - assertEquals(one,a.get(this)); - a.set(this,two); - assertEquals(two,a.get(this)); - a.set(this,m3); - assertEquals(m3,a.get(this)); + assertSame(one,a.get(this)); + a.lazySet(this,two); + assertSame(two,a.get(this)); + a.lazySet(this,m3); + assertSame(m3,a.get(this)); } + /** * compareAndSet succeeds in changing value if equal to expected else fails */ - public void testCompareAndSet(){ + public void testCompareAndSet() { AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a; try { a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x"); @@ -112,18 +107,18 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase{ x = one; assertTrue(a.compareAndSet(this,one,two)); assertTrue(a.compareAndSet(this,two,m4)); - assertEquals(m4,a.get(this)); + assertSame(m4,a.get(this)); assertFalse(a.compareAndSet(this,m5,seven)); - assertFalse((seven == a.get(this))); + assertFalse(seven == a.get(this)); assertTrue(a.compareAndSet(this,m4,seven)); - assertEquals(seven,a.get(this)); + assertSame(seven,a.get(this)); } /** * compareAndSet in one thread enables another waiting for value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws Exception { x = one; final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a; try { @@ -132,27 +127,24 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase{ return; } - Thread t = new Thread(new Runnable() { - public void run() { - while(!a.compareAndSet(AtomicReferenceFieldUpdaterTest.this, two, three)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(a.compareAndSet(this, one, two)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(a.get(this), three); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!a.compareAndSet(AtomicReferenceFieldUpdaterTest.this, two, three)) + Thread.yield(); + }}); + + t.start(); + assertTrue(a.compareAndSet(this, one, two)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertSame(a.get(this), three); } /** * repeated weakCompareAndSet succeeds in changing value when equal * to expected */ - public void testWeakCompareAndSet(){ + public void testWeakCompareAndSet() { AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a; try { a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x"); @@ -160,17 +152,17 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase{ return; } x = one; - while(!a.weakCompareAndSet(this,one,two)); - while(!a.weakCompareAndSet(this,two,m4)); - assertEquals(m4,a.get(this)); - while(!a.weakCompareAndSet(this,m4,seven)); - assertEquals(seven,a.get(this)); + while (!a.weakCompareAndSet(this,one,two)); + while (!a.weakCompareAndSet(this,two,m4)); + assertSame(m4,a.get(this)); + while (!a.weakCompareAndSet(this,m4,seven)); + assertSame(seven,a.get(this)); } /** * getAndSet returns previous value and sets to given value */ - public void testGetAndSet(){ + public void testGetAndSet() { AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a; try { a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x"); @@ -178,9 +170,9 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase{ return; } x = one; - assertEquals(one,a.getAndSet(this, zero)); - assertEquals(zero,a.getAndSet(this,m10)); - assertEquals(m10,a.getAndSet(this,1)); + assertSame(one,a.getAndSet(this, zero)); + assertSame(zero,a.getAndSet(this,m10)); + assertSame(m10,a.getAndSet(this,1)); } } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceTest.java index bcb4701..5046ee8 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.atomic.*; @@ -20,15 +20,15 @@ public class AtomicReferenceTest extends JSR166TestCase { /** * constructor initializes to given value */ - public void testConstructor(){ + public void testConstructor() { AtomicReference ai = new AtomicReference(one); - assertEquals(one,ai.get()); + assertSame(one,ai.get()); } /** * default constructed initializes to null */ - public void testConstructor2(){ + public void testConstructor2() { AtomicReference ai = new AtomicReference(); assertNull(ai.get()); } @@ -36,105 +36,109 @@ public class AtomicReferenceTest extends JSR166TestCase { /** * get returns the last value set */ - public void testGetSet(){ + public void testGetSet() { AtomicReference ai = new AtomicReference(one); - assertEquals(one,ai.get()); + assertSame(one,ai.get()); ai.set(two); - assertEquals(two,ai.get()); + assertSame(two,ai.get()); ai.set(m3); - assertEquals(m3,ai.get()); + assertSame(m3,ai.get()); + } + /** + * get returns the last value lazySet in same thread + */ + public void testGetLazySet() { + AtomicReference ai = new AtomicReference(one); + assertSame(one,ai.get()); + ai.lazySet(two); + assertSame(two,ai.get()); + ai.lazySet(m3); + assertSame(m3,ai.get()); } + /** * compareAndSet succeeds in changing value if equal to expected else fails */ - public void testCompareAndSet(){ + public void testCompareAndSet() { AtomicReference ai = new AtomicReference(one); assertTrue(ai.compareAndSet(one,two)); assertTrue(ai.compareAndSet(two,m4)); - assertEquals(m4,ai.get()); + assertSame(m4,ai.get()); assertFalse(ai.compareAndSet(m5,seven)); - assertFalse((seven.equals(ai.get()))); + assertSame(m4,ai.get()); assertTrue(ai.compareAndSet(m4,seven)); - assertEquals(seven,ai.get()); + assertSame(seven,ai.get()); } /** * compareAndSet in one thread enables another waiting for value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws Exception { final AtomicReference ai = new AtomicReference(one); - Thread t = new Thread(new Runnable() { - public void run() { - while(!ai.compareAndSet(two, three)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(ai.compareAndSet(one, two)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(ai.get(), three); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!ai.compareAndSet(two, three)) + Thread.yield(); + }}); + + t.start(); + assertTrue(ai.compareAndSet(one, two)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertSame(ai.get(), three); } /** * repeated weakCompareAndSet succeeds in changing value when equal * to expected */ - public void testWeakCompareAndSet(){ + public void testWeakCompareAndSet() { AtomicReference ai = new AtomicReference(one); - while(!ai.weakCompareAndSet(one,two)); - while(!ai.weakCompareAndSet(two,m4)); - assertEquals(m4,ai.get()); - while(!ai.weakCompareAndSet(m4,seven)); - assertEquals(seven,ai.get()); + while (!ai.weakCompareAndSet(one,two)); + while (!ai.weakCompareAndSet(two,m4)); + assertSame(m4,ai.get()); + while (!ai.weakCompareAndSet(m4,seven)); + assertSame(seven,ai.get()); } /** * getAndSet returns previous value and sets to given value */ - public void testGetAndSet(){ + public void testGetAndSet() { AtomicReference ai = new AtomicReference(one); - assertEquals(one,ai.getAndSet(zero)); - assertEquals(zero,ai.getAndSet(m10)); - assertEquals(m10,ai.getAndSet(one)); + assertSame(one,ai.getAndSet(zero)); + assertSame(zero,ai.getAndSet(m10)); + assertSame(m10,ai.getAndSet(one)); } /** * a deserialized serialized atomic holds same value */ - public void testSerialization() { + public void testSerialization() throws Exception { AtomicReference l = new AtomicReference(); - try { - l.set(one); - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - AtomicReference r = (AtomicReference) in.readObject(); - assertEquals(l.get(), r.get()); - } catch(Exception e){ - unexpectedException(); - } + l.set(one); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + AtomicReference r = (AtomicReference) in.readObject(); + assertEquals(l.get(), r.get()); } /** * toString returns current value. - */ + */ public void testToString() { - AtomicReference<Integer> ai = new AtomicReference<Integer>(one); + AtomicReference<Integer> ai = new AtomicReference<Integer>(one); assertEquals(ai.toString(), one.toString()); ai.set(two); assertEquals(ai.toString(), two.toString()); } } - diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicStampedReferenceTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicStampedReferenceTest.java index 9f4e4f7..ca9b724 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicStampedReferenceTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicStampedReferenceTest.java @@ -2,65 +2,64 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.atomic.*; -public class AtomicStampedReferenceTest extends JSR166TestCase{ +public class AtomicStampedReferenceTest extends JSR166TestCase { public static Test suite() { return new TestSuite(AtomicStampedReferenceTest.class); } - + /** * constructor initializes to given reference and stamp */ - public void testConstructor(){ + public void testConstructor() { AtomicStampedReference ai = new AtomicStampedReference(one, 0); - assertEquals(one,ai.getReference()); + assertSame(one,ai.getReference()); assertEquals(0, ai.getStamp()); AtomicStampedReference a2 = new AtomicStampedReference(null, 1); assertNull(a2.getReference()); assertEquals(1, a2.getStamp()); - } /** * get returns the last values of reference and stamp set */ - public void testGetSet(){ + public void testGetSet() { int[] mark = new int[1]; AtomicStampedReference ai = new AtomicStampedReference(one, 0); - assertEquals(one,ai.getReference()); + assertSame(one,ai.getReference()); assertEquals(0, ai.getStamp()); - assertEquals(one, ai.get(mark)); + assertSame(one, ai.get(mark)); assertEquals(0, mark[0]); ai.set(two, 0); - assertEquals(two,ai.getReference()); + assertSame(two,ai.getReference()); assertEquals(0, ai.getStamp()); - assertEquals(two, ai.get(mark)); + assertSame(two, ai.get(mark)); assertEquals(0, mark[0]); ai.set(one, 1); - assertEquals(one,ai.getReference()); + assertSame(one,ai.getReference()); assertEquals(1, ai.getStamp()); - assertEquals(one, ai.get(mark)); + assertSame(one, ai.get(mark)); assertEquals(1,mark[0]); } /** * attemptStamp succeeds in single thread */ - public void testAttemptStamp(){ + public void testAttemptStamp() { int[] mark = new int[1]; AtomicStampedReference ai = new AtomicStampedReference(one, 0); assertEquals(0, ai.getStamp()); assertTrue(ai.attemptStamp(one, 1)); assertEquals(1, ai.getStamp()); - assertEquals(one, ai.get(mark)); + assertSame(one, ai.get(mark)); assertEquals(1, mark[0]); } @@ -68,23 +67,23 @@ public class AtomicStampedReferenceTest extends JSR166TestCase{ * compareAndSet succeeds in changing values if equal to expected reference * and stamp else fails */ - public void testCompareAndSet(){ + public void testCompareAndSet() { int[] mark = new int[1]; AtomicStampedReference ai = new AtomicStampedReference(one, 0); - assertEquals(one, ai.get(mark)); + assertSame(one, ai.get(mark)); assertEquals(0, ai.getStamp()); assertEquals(0, mark[0]); assertTrue(ai.compareAndSet(one, two, 0, 0)); - assertEquals(two, ai.get(mark)); + assertSame(two, ai.get(mark)); assertEquals(0, mark[0]); assertTrue(ai.compareAndSet(two, m3, 0, 1)); - assertEquals(m3, ai.get(mark)); + assertSame(m3, ai.get(mark)); assertEquals(1, mark[0]); assertFalse(ai.compareAndSet(two, m3, 1, 1)); - assertEquals(m3, ai.get(mark)); + assertSame(m3, ai.get(mark)); assertEquals(1, mark[0]); } @@ -92,65 +91,59 @@ public class AtomicStampedReferenceTest extends JSR166TestCase{ * compareAndSet in one thread enables another waiting for reference value * to succeed */ - public void testCompareAndSetInMultipleThreads() { + public void testCompareAndSetInMultipleThreads() throws Exception { final AtomicStampedReference ai = new AtomicStampedReference(one, 0); - Thread t = new Thread(new Runnable() { - public void run() { - while(!ai.compareAndSet(two, three, 0, 0)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(ai.compareAndSet(one, two, 0, 0)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(ai.getReference(), three); - assertEquals(ai.getStamp(), 0); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!ai.compareAndSet(two, three, 0, 0)) + Thread.yield(); + }}); + + t.start(); + assertTrue(ai.compareAndSet(one, two, 0, 0)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertSame(ai.getReference(), three); + assertEquals(ai.getStamp(), 0); } /** * compareAndSet in one thread enables another waiting for stamp value * to succeed */ - public void testCompareAndSetInMultipleThreads2() { + public void testCompareAndSetInMultipleThreads2() throws Exception { final AtomicStampedReference ai = new AtomicStampedReference(one, 0); - Thread t = new Thread(new Runnable() { - public void run() { - while(!ai.compareAndSet(one, one, 1, 2)) Thread.yield(); - }}); - try { - t.start(); - assertTrue(ai.compareAndSet(one, one, 0, 1)); - t.join(LONG_DELAY_MS); - assertFalse(t.isAlive()); - assertEquals(ai.getReference(), one); - assertEquals(ai.getStamp(), 2); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + while (!ai.compareAndSet(one, one, 1, 2)) + Thread.yield(); + }}); + + t.start(); + assertTrue(ai.compareAndSet(one, one, 0, 1)); + t.join(LONG_DELAY_MS); + assertFalse(t.isAlive()); + assertSame(ai.getReference(), one); + assertEquals(ai.getStamp(), 2); } /** * repeated weakCompareAndSet succeeds in changing values when equal - * to expected + * to expected */ - public void testWeakCompareAndSet(){ + public void testWeakCompareAndSet() { int[] mark = new int[1]; AtomicStampedReference ai = new AtomicStampedReference(one, 0); - assertEquals(one, ai.get(mark)); + assertSame(one, ai.get(mark)); assertEquals(0, ai.getStamp ()); assertEquals(0, mark[0]); - while(!ai.weakCompareAndSet(one, two, 0, 0)); - assertEquals(two, ai.get(mark)); + while (!ai.weakCompareAndSet(one, two, 0, 0)); + assertSame(two, ai.get(mark)); assertEquals(0, mark[0]); - while(!ai.weakCompareAndSet(two, m3, 0, 1)); - assertEquals(m3, ai.get(mark)); + while (!ai.weakCompareAndSet(two, m3, 0, 1)); + assertSame(m3, ai.get(mark)); assertEquals(1, mark[0]); } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentHashMapTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentHashMapTest.java index b7549a4..9b355f5 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentHashMapTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentHashMapTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; @@ -14,7 +14,7 @@ import java.util.concurrent.*; import java.util.Enumeration; import java.io.*; -public class ConcurrentHashMapTest extends JSR166TestCase{ +public class ConcurrentHashMapTest extends JSR166TestCase { public static Test suite() { return new TestSuite(ConcurrentHashMapTest.class); } @@ -80,7 +80,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ */ public void testContainsValue() { ConcurrentHashMap map = map5(); - assertTrue(map.containsValue("A")); + assertTrue(map.containsValue("A")); assertFalse(map.containsValue("Z")); } @@ -92,7 +92,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap map = map5(); Enumeration e = map.elements(); int count = 0; - while(e.hasMoreElements()){ + while (e.hasMoreElements()) { count++; e.nextElement(); } @@ -127,7 +127,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap map = map5(); Enumeration e = map.keys(); int count = 0; - while(e.hasMoreElements()){ + while (e.hasMoreElements()) { count++; e.nextElement(); } @@ -153,10 +153,10 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ */ public void testKeySetToArray() { ConcurrentHashMap map = map5(); - Set s = map.keySet(); + Set s = map.keySet(); Object[] ar = s.toArray(); assertTrue(s.containsAll(Arrays.asList(ar))); - assertEquals(5, ar.length); + assertEquals(5, ar.length); ar[0] = m10; assertFalse(s.containsAll(Arrays.asList(ar))); } @@ -166,15 +166,15 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ */ public void testValuesToArray() { ConcurrentHashMap map = map5(); - Collection v = map.values(); + Collection v = map.values(); Object[] ar = v.toArray(); ArrayList s = new ArrayList(Arrays.asList(ar)); - assertEquals(5, ar.length); - assertTrue(s.contains("A")); - assertTrue(s.contains("B")); - assertTrue(s.contains("C")); - assertTrue(s.contains("D")); - assertTrue(s.contains("E")); + assertEquals(5, ar.length); + assertTrue(s.contains("A")); + assertTrue(s.contains("B")); + assertTrue(s.contains("C")); + assertTrue(s.contains("D")); + assertTrue(s.contains("E")); } /** @@ -182,7 +182,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ */ public void testEntrySetToArray() { ConcurrentHashMap map = map5(); - Set s = map.entrySet(); + Set s = map.entrySet(); Object[] ar = s.toArray(); assertEquals(5, ar.length); for (int i = 0; i < 5; ++i) { @@ -317,7 +317,6 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ map.remove(four, "A"); assertEquals(4, map.size()); assertTrue(map.containsKey(four)); - } /** @@ -350,7 +349,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ try { new ConcurrentHashMap(-1,0,1); shouldThrow(); - } catch(IllegalArgumentException e){} + } catch (IllegalArgumentException success) {} } /** @@ -360,7 +359,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ try { new ConcurrentHashMap(1,0,-1); shouldThrow(); - } catch(IllegalArgumentException e){} + } catch (IllegalArgumentException success) {} } /** @@ -370,7 +369,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ try { new ConcurrentHashMap(-1); shouldThrow(); - } catch(IllegalArgumentException e){} + } catch (IllegalArgumentException success) {} } /** @@ -381,7 +380,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.get(null); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -392,7 +391,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.containsKey(null); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -403,7 +402,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.containsValue(null); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -414,7 +413,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.contains(null); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -425,7 +424,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.put(null, "whatever"); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -436,7 +435,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.put("whatever", null); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -447,7 +446,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.putIfAbsent(null, "whatever"); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -458,7 +457,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.replace(null, "whatever"); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -469,7 +468,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.replace(null, one, "whatever"); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -480,7 +479,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.putIfAbsent("whatever", null); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } @@ -492,7 +491,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.replace("whatever", null); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -503,7 +502,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.replace("whatever", null, "A"); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -514,7 +513,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ ConcurrentHashMap c = new ConcurrentHashMap(5); c.replace("whatever", one, null); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } @@ -527,7 +526,7 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ c.put("sadsdf", "asdads"); c.remove(null); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** @@ -539,44 +538,35 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ c.put("sadsdf", "asdads"); c.remove(null, "whatever"); shouldThrow(); - } catch(NullPointerException e){} + } catch (NullPointerException success) {} } /** * remove(x, null) returns false */ public void testRemove3() { - try { - ConcurrentHashMap c = new ConcurrentHashMap(5); - c.put("sadsdf", "asdads"); - assertFalse(c.remove("sadsdf", null)); - } catch(NullPointerException e){ - fail(); - } + ConcurrentHashMap c = new ConcurrentHashMap(5); + c.put("sadsdf", "asdads"); + assertFalse(c.remove("sadsdf", null)); } /** * A deserialized map equals original */ - public void testSerialization() { + public void testSerialization() throws Exception { ConcurrentHashMap q = map5(); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(q); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - ConcurrentHashMap r = (ConcurrentHashMap)in.readObject(); - assertEquals(q.size(), r.size()); - assertTrue(q.equals(r)); - assertTrue(r.equals(q)); - } catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + ConcurrentHashMap r = (ConcurrentHashMap)in.readObject(); + assertEquals(q.size(), r.size()); + assertTrue(q.equals(r)); + assertTrue(r.equals(q)); } @@ -584,23 +574,23 @@ public class ConcurrentHashMapTest extends JSR166TestCase{ * SetValue of an EntrySet entry sets value in the map. */ public void testSetValueWriteThrough() { - // Adapted from a bug report by Eric Zoerner + // Adapted from a bug report by Eric Zoerner ConcurrentHashMap map = new ConcurrentHashMap(2, 5.0f, 1); assertTrue(map.isEmpty()); for (int i = 0; i < 20; i++) map.put(new Integer(i), new Integer(i)); assertFalse(map.isEmpty()); Map.Entry entry1 = (Map.Entry)map.entrySet().iterator().next(); - + // assert that entry1 is not 16 assertTrue("entry is 16, test not valid", !entry1.getKey().equals(new Integer(16))); - - // remove 16 (a different key) from map + + // remove 16 (a different key) from map // which just happens to cause entry1 to be cloned in map map.remove(new Integer(16)); entry1.setValue("XYZ"); assertTrue(map.containsValue("XYZ")); // fails } - + } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentLinkedQueueTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentLinkedQueueTest.java index c84dc59..1fbc729 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentLinkedQueueTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentLinkedQueueTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; @@ -25,13 +25,13 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { private ConcurrentLinkedQueue populatedQueue(int n) { ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); assertTrue(q.isEmpty()); - for(int i = 0; i < n; ++i) + for (int i = 0; i < n; ++i) assertTrue(q.offer(new Integer(i))); assertFalse(q.isEmpty()); assertEquals(n, q.size()); return q; } - + /** * new queue is empty */ @@ -46,8 +46,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { try { ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -58,8 +57,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -72,23 +70,19 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { ints[i] = new Integer(i); ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * Queue contains all elements of collection used to initialize */ public void testConstructor6() { - try { - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints)); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); - } - finally {} + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints)); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); } /** @@ -128,7 +122,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); q.offer(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -139,7 +133,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); q.add(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } @@ -171,8 +165,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); q.addAll(null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -183,8 +176,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { ConcurrentLinkedQueue q = populatedQueue(SIZE); q.addAll(q); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } /** @@ -196,8 +188,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll of a collection with any null elements throws NPE after @@ -211,26 +202,22 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { ints[i] = new Integer(i); q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * Queue contains all elements, in traversal order, of successful addAll */ public void testAddAll5() { - try { - Integer[] empty = new Integer[0]; - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); - assertFalse(q.addAll(Arrays.asList(empty))); - assertTrue(q.addAll(Arrays.asList(ints))); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); - } - finally {} + Integer[] empty = new Integer[0]; + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + assertFalse(q.addAll(Arrays.asList(empty))); + assertTrue(q.addAll(Arrays.asList(ints))); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); } /** @@ -239,7 +226,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { public void testPoll() { ConcurrentLinkedQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.poll()).intValue()); + assertEquals(i, q.poll()); } assertNull(q.poll()); } @@ -250,10 +237,10 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { public void testPeek() { ConcurrentLinkedQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.peek()).intValue()); - q.poll(); + assertEquals(i, q.peek()); + assertEquals(i, q.poll()); assertTrue(q.peek() == null || - i != ((Integer)q.peek()).intValue()); + !q.peek().equals(i)); } assertNull(q.peek()); } @@ -264,14 +251,13 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { public void testElement() { ConcurrentLinkedQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.element()).intValue()); - q.poll(); + assertEquals(i, q.element()); + assertEquals(i, q.poll()); } try { q.element(); shouldThrow(); - } - catch (NoSuchElementException success) {} + } catch (NoSuchElementException success) {} } /** @@ -280,13 +266,12 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { public void testRemove() { ConcurrentLinkedQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.remove()).intValue()); + assertEquals(i, q.remove()); } try { q.remove(); shouldThrow(); - } catch (NoSuchElementException success){ - } + } catch (NoSuchElementException success) {} } /** @@ -303,7 +288,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { } assertTrue(q.isEmpty()); } - + /** * contains(x) reports true when elements added but not yet removed */ @@ -386,7 +371,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { ConcurrentLinkedQueue q = populatedQueue(SIZE); Object[] o = q.toArray(); Arrays.sort(o); - for(int i = 0; i < o.length; i++) + for (int i = 0; i < o.length; i++) assertEquals(o[i], q.poll()); } @@ -398,7 +383,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; ints = (Integer[])q.toArray(ints); Arrays.sort(ints); - for(int i = 0; i < ints.length; i++) + for (int i = 0; i < ints.length; i++) assertEquals(ints[i], q.poll()); } @@ -406,24 +391,24 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { * toArray(null) throws NPE */ public void testToArray_BadArg() { + ConcurrentLinkedQueue q = populatedQueue(SIZE); try { - ConcurrentLinkedQueue q = populatedQueue(SIZE); Object o[] = q.toArray(null); shouldThrow(); - } catch(NullPointerException success){} + } catch (NullPointerException success) {} } /** - * toArray with incompatible array type throws CCE + * toArray with incompatible array type throws ArrayStoreException */ public void testToArray1_BadArg() { + ConcurrentLinkedQueue q = populatedQueue(SIZE); try { - ConcurrentLinkedQueue q = populatedQueue(SIZE); - Object o[] = q.toArray(new String[10] ); + Object o[] = q.toArray(new String[10]); shouldThrow(); - } catch(ArrayStoreException success){} + } catch (ArrayStoreException success) {} } - + /** * iterator iterates through all elements */ @@ -431,7 +416,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { ConcurrentLinkedQueue q = populatedQueue(SIZE); int i = 0; Iterator it = q.iterator(); - while(it.hasNext()) { + while (it.hasNext()) { assertTrue(q.contains(it.next())); ++i; } @@ -449,8 +434,7 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { int k = 0; for (Iterator it = q.iterator(); it.hasNext();) { - int i = ((Integer)(it.next())).intValue(); - assertEquals(++k, i); + assertEquals(++k, it.next()); } assertEquals(3, k); @@ -465,14 +449,9 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { q.add(two); q.add(three); - try { - for (Iterator it = q.iterator(); it.hasNext();) { - q.remove(); - it.next(); - } - } - catch (ConcurrentModificationException e) { - shouldThrow(); + for (Iterator it = q.iterator(); it.hasNext();) { + q.remove(); + it.next(); } assertEquals("queue should be empty again", 0, q.size()); @@ -490,8 +469,8 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { it.next(); it.remove(); it = q.iterator(); - assertEquals(it.next(), two); - assertEquals(it.next(), three); + assertSame(it.next(), two); + assertSame(it.next(), three); assertFalse(it.hasNext()); } @@ -505,28 +484,24 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase { for (int i = 0; i < SIZE; ++i) { assertTrue(s.indexOf(String.valueOf(i)) >= 0); } - } + } /** * A deserialized serialized queue has same elements in same order */ - public void testSerialization() { + public void testSerialization() throws Exception { ConcurrentLinkedQueue q = populatedQueue(SIZE); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(q); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - ConcurrentLinkedQueue r = (ConcurrentLinkedQueue)in.readObject(); - assertEquals(q.size(), r.size()); - while (!q.isEmpty()) - assertEquals(q.remove(), r.remove()); - } catch(Exception e){ - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + ConcurrentLinkedQueue r = (ConcurrentLinkedQueue)in.readObject(); + assertEquals(q.size(), r.size()); + while (!q.isEmpty()) + assertEquals(q.remove(), r.remove()); } } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListMapTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListMapTest.java new file mode 100644 index 0000000..3cf5b75 --- /dev/null +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListMapTest.java @@ -0,0 +1,1280 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + */ + +package tests.api.java.util.concurrent; // android-added + +import junit.framework.*; +import java.util.*; +import java.util.concurrent.*; +import java.io.*; + +public class ConcurrentSkipListMapTest extends JSR166TestCase { + public static Test suite() { + return new TestSuite(ConcurrentSkipListMapTest.class); + } + + /** + * Create a map from Integers 1-5 to Strings "A"-"E". + */ + private static ConcurrentSkipListMap map5() { + ConcurrentSkipListMap map = new ConcurrentSkipListMap(); + assertTrue(map.isEmpty()); + map.put(one, "A"); + map.put(five, "E"); + map.put(three, "C"); + map.put(two, "B"); + map.put(four, "D"); + assertFalse(map.isEmpty()); + assertEquals(5, map.size()); + return map; + } + + /** + * clear removes all pairs + */ + public void testClear() { + ConcurrentSkipListMap map = map5(); + map.clear(); + assertEquals(map.size(), 0); + } + + /** + * + */ + public void testConstructFromSorted() { + ConcurrentSkipListMap map = map5(); + ConcurrentSkipListMap map2 = new ConcurrentSkipListMap(map); + assertEquals(map, map2); + } + + /** + * Maps with same contents are equal + */ + public void testEquals() { + ConcurrentSkipListMap map1 = map5(); + ConcurrentSkipListMap map2 = map5(); + assertEquals(map1, map2); + assertEquals(map2, map1); + map1.clear(); + assertFalse(map1.equals(map2)); + assertFalse(map2.equals(map1)); + } + + /** + * containsKey returns true for contained key + */ + public void testContainsKey() { + ConcurrentSkipListMap map = map5(); + assertTrue(map.containsKey(one)); + assertFalse(map.containsKey(zero)); + } + + /** + * containsValue returns true for held values + */ + public void testContainsValue() { + ConcurrentSkipListMap map = map5(); + assertTrue(map.containsValue("A")); + assertFalse(map.containsValue("Z")); + } + + /** + * get returns the correct element at the given key, + * or null if not present + */ + public void testGet() { + ConcurrentSkipListMap map = map5(); + assertEquals("A", (String)map.get(one)); + ConcurrentSkipListMap empty = new ConcurrentSkipListMap(); + assertNull(empty.get(one)); + } + + /** + * isEmpty is true of empty map and false for non-empty + */ + public void testIsEmpty() { + ConcurrentSkipListMap empty = new ConcurrentSkipListMap(); + ConcurrentSkipListMap map = map5(); + assertTrue(empty.isEmpty()); + assertFalse(map.isEmpty()); + } + + /** + * firstKey returns first key + */ + public void testFirstKey() { + ConcurrentSkipListMap map = map5(); + assertEquals(one, map.firstKey()); + } + + /** + * lastKey returns last key + */ + public void testLastKey() { + ConcurrentSkipListMap map = map5(); + assertEquals(five, map.lastKey()); + } + + + /** + * keySet.toArray returns contains all keys + */ + public void testKeySetToArray() { + ConcurrentSkipListMap map = map5(); + Set s = map.keySet(); + Object[] ar = s.toArray(); + assertTrue(s.containsAll(Arrays.asList(ar))); + assertEquals(5, ar.length); + ar[0] = m10; + assertFalse(s.containsAll(Arrays.asList(ar))); + } + + /** + * descendingkeySet.toArray returns contains all keys + */ + public void testDescendingKeySetToArray() { + ConcurrentSkipListMap map = map5(); + Set s = map.descendingKeySet(); + Object[] ar = s.toArray(); + assertEquals(5, ar.length); + assertTrue(s.containsAll(Arrays.asList(ar))); + ar[0] = m10; + assertFalse(s.containsAll(Arrays.asList(ar))); + } + + /** + * keySet returns a Set containing all the keys + */ + public void testKeySet() { + ConcurrentSkipListMap map = map5(); + Set s = map.keySet(); + assertEquals(5, s.size()); + assertTrue(s.contains(one)); + assertTrue(s.contains(two)); + assertTrue(s.contains(three)); + assertTrue(s.contains(four)); + assertTrue(s.contains(five)); + } + + /** + * keySet is ordered + */ + public void testKeySetOrder() { + ConcurrentSkipListMap map = map5(); + Set s = map.keySet(); + Iterator i = s.iterator(); + Integer last = (Integer)i.next(); + assertEquals(last, one); + int count = 1; + while (i.hasNext()) { + Integer k = (Integer)i.next(); + assertTrue(last.compareTo(k) < 0); + last = k; + ++count; + } + assertEquals(count ,5); + } + + /** + * descending iterator of key set is inverse ordered + */ + public void testKeySetDescendingIteratorOrder() { + ConcurrentSkipListMap map = map5(); + NavigableSet s = map.navigableKeySet(); + Iterator i = s.descendingIterator(); + Integer last = (Integer)i.next(); + assertEquals(last, five); + int count = 1; + while (i.hasNext()) { + Integer k = (Integer)i.next(); + assertTrue(last.compareTo(k) > 0); + last = k; + ++count; + } + assertEquals(count ,5); + } + + /** + * descendingKeySet is ordered + */ + public void testDescendingKeySetOrder() { + ConcurrentSkipListMap map = map5(); + Set s = map.descendingKeySet(); + Iterator i = s.iterator(); + Integer last = (Integer)i.next(); + assertEquals(last, five); + int count = 1; + while (i.hasNext()) { + Integer k = (Integer)i.next(); + assertTrue(last.compareTo(k) > 0); + last = k; + ++count; + } + assertEquals(count, 5); + } + + /** + * descending iterator of descendingKeySet is ordered + */ + public void testDescendingKeySetDescendingIteratorOrder() { + ConcurrentSkipListMap map = map5(); + NavigableSet s = map.descendingKeySet(); + Iterator i = s.descendingIterator(); + Integer last = (Integer)i.next(); + assertEquals(last, one); + int count = 1; + while (i.hasNext()) { + Integer k = (Integer)i.next(); + assertTrue(last.compareTo(k) < 0); + last = k; + ++count; + } + assertEquals(count, 5); + } + + /** + * Values.toArray contains all values + */ + public void testValuesToArray() { + ConcurrentSkipListMap map = map5(); + Collection v = map.values(); + Object[] ar = v.toArray(); + ArrayList s = new ArrayList(Arrays.asList(ar)); + assertEquals(5, ar.length); + assertTrue(s.contains("A")); + assertTrue(s.contains("B")); + assertTrue(s.contains("C")); + assertTrue(s.contains("D")); + assertTrue(s.contains("E")); + } + + /** + * values collection contains all values + */ + public void testValues() { + ConcurrentSkipListMap map = map5(); + Collection s = map.values(); + assertEquals(5, s.size()); + assertTrue(s.contains("A")); + assertTrue(s.contains("B")); + assertTrue(s.contains("C")); + assertTrue(s.contains("D")); + assertTrue(s.contains("E")); + } + + /** + * entrySet contains all pairs + */ + public void testEntrySet() { + ConcurrentSkipListMap map = map5(); + Set s = map.entrySet(); + assertEquals(5, s.size()); + Iterator it = s.iterator(); + while (it.hasNext()) { + Map.Entry e = (Map.Entry) it.next(); + assertTrue( + (e.getKey().equals(one) && e.getValue().equals("A")) || + (e.getKey().equals(two) && e.getValue().equals("B")) || + (e.getKey().equals(three) && e.getValue().equals("C")) || + (e.getKey().equals(four) && e.getValue().equals("D")) || + (e.getKey().equals(five) && e.getValue().equals("E"))); + } + } + + /** + * descendingEntrySet contains all pairs + */ + public void testDescendingEntrySet() { + ConcurrentSkipListMap map = map5(); + Set s = map.descendingMap().entrySet(); + assertEquals(5, s.size()); + Iterator it = s.iterator(); + while (it.hasNext()) { + Map.Entry e = (Map.Entry) it.next(); + assertTrue( + (e.getKey().equals(one) && e.getValue().equals("A")) || + (e.getKey().equals(two) && e.getValue().equals("B")) || + (e.getKey().equals(three) && e.getValue().equals("C")) || + (e.getKey().equals(four) && e.getValue().equals("D")) || + (e.getKey().equals(five) && e.getValue().equals("E"))); + } + } + + /** + * entrySet.toArray contains all entries + */ + public void testEntrySetToArray() { + ConcurrentSkipListMap map = map5(); + Set s = map.entrySet(); + Object[] ar = s.toArray(); + assertEquals(5, ar.length); + for (int i = 0; i < 5; ++i) { + assertTrue(map.containsKey(((Map.Entry)(ar[i])).getKey())); + assertTrue(map.containsValue(((Map.Entry)(ar[i])).getValue())); + } + } + + /** + * descendingEntrySet.toArray contains all entries + */ + public void testDescendingEntrySetToArray() { + ConcurrentSkipListMap map = map5(); + Set s = map.descendingMap().entrySet(); + Object[] ar = s.toArray(); + assertEquals(5, ar.length); + for (int i = 0; i < 5; ++i) { + assertTrue(map.containsKey(((Map.Entry)(ar[i])).getKey())); + assertTrue(map.containsValue(((Map.Entry)(ar[i])).getValue())); + } + } + + /** + * putAll adds all key-value pairs from the given map + */ + public void testPutAll() { + ConcurrentSkipListMap empty = new ConcurrentSkipListMap(); + ConcurrentSkipListMap map = map5(); + empty.putAll(map); + assertEquals(5, empty.size()); + assertTrue(empty.containsKey(one)); + assertTrue(empty.containsKey(two)); + assertTrue(empty.containsKey(three)); + assertTrue(empty.containsKey(four)); + assertTrue(empty.containsKey(five)); + } + + /** + * putIfAbsent works when the given key is not present + */ + public void testPutIfAbsent() { + ConcurrentSkipListMap map = map5(); + map.putIfAbsent(six, "Z"); + assertTrue(map.containsKey(six)); + } + + /** + * putIfAbsent does not add the pair if the key is already present + */ + public void testPutIfAbsent2() { + ConcurrentSkipListMap map = map5(); + assertEquals("A", map.putIfAbsent(one, "Z")); + } + + /** + * replace fails when the given key is not present + */ + public void testReplace() { + ConcurrentSkipListMap map = map5(); + assertNull(map.replace(six, "Z")); + assertFalse(map.containsKey(six)); + } + + /** + * replace succeeds if the key is already present + */ + public void testReplace2() { + ConcurrentSkipListMap map = map5(); + assertNotNull(map.replace(one, "Z")); + assertEquals("Z", map.get(one)); + } + + + /** + * replace value fails when the given key not mapped to expected value + */ + public void testReplaceValue() { + ConcurrentSkipListMap map = map5(); + assertEquals("A", map.get(one)); + assertFalse(map.replace(one, "Z", "Z")); + assertEquals("A", map.get(one)); + } + + /** + * replace value succeeds when the given key mapped to expected value + */ + public void testReplaceValue2() { + ConcurrentSkipListMap map = map5(); + assertEquals("A", map.get(one)); + assertTrue(map.replace(one, "A", "Z")); + assertEquals("Z", map.get(one)); + } + + + /** + * remove removes the correct key-value pair from the map + */ + public void testRemove() { + ConcurrentSkipListMap map = map5(); + map.remove(five); + assertEquals(4, map.size()); + assertFalse(map.containsKey(five)); + } + + /** + * remove(key,value) removes only if pair present + */ + public void testRemove2() { + ConcurrentSkipListMap map = map5(); + assertTrue(map.containsKey(five)); + assertEquals("E", map.get(five)); + map.remove(five, "E"); + assertEquals(4, map.size()); + assertFalse(map.containsKey(five)); + map.remove(four, "A"); + assertEquals(4, map.size()); + assertTrue(map.containsKey(four)); + } + + /** + * lowerEntry returns preceding entry. + */ + public void testLowerEntry() { + ConcurrentSkipListMap map = map5(); + Map.Entry e1 = map.lowerEntry(three); + assertEquals(two, e1.getKey()); + + Map.Entry e2 = map.lowerEntry(six); + assertEquals(five, e2.getKey()); + + Map.Entry e3 = map.lowerEntry(one); + assertNull(e3); + + Map.Entry e4 = map.lowerEntry(zero); + assertNull(e4); + } + + /** + * higherEntry returns next entry. + */ + public void testHigherEntry() { + ConcurrentSkipListMap map = map5(); + Map.Entry e1 = map.higherEntry(three); + assertEquals(four, e1.getKey()); + + Map.Entry e2 = map.higherEntry(zero); + assertEquals(one, e2.getKey()); + + Map.Entry e3 = map.higherEntry(five); + assertNull(e3); + + Map.Entry e4 = map.higherEntry(six); + assertNull(e4); + } + + /** + * floorEntry returns preceding entry. + */ + public void testFloorEntry() { + ConcurrentSkipListMap map = map5(); + Map.Entry e1 = map.floorEntry(three); + assertEquals(three, e1.getKey()); + + Map.Entry e2 = map.floorEntry(six); + assertEquals(five, e2.getKey()); + + Map.Entry e3 = map.floorEntry(one); + assertEquals(one, e3.getKey()); + + Map.Entry e4 = map.floorEntry(zero); + assertNull(e4); + } + + /** + * ceilingEntry returns next entry. + */ + public void testCeilingEntry() { + ConcurrentSkipListMap map = map5(); + Map.Entry e1 = map.ceilingEntry(three); + assertEquals(three, e1.getKey()); + + Map.Entry e2 = map.ceilingEntry(zero); + assertEquals(one, e2.getKey()); + + Map.Entry e3 = map.ceilingEntry(five); + assertEquals(five, e3.getKey()); + + Map.Entry e4 = map.ceilingEntry(six); + assertNull(e4); + } + + /** + * lowerEntry, higherEntry, ceilingEntry, and floorEntry return + * immutable entries + */ + public void testEntryImmutablity() { + ConcurrentSkipListMap map = map5(); + Map.Entry e = map.lowerEntry(three); + assertEquals(two, e.getKey()); + try { + e.setValue("X"); + shouldThrow(); + } catch (UnsupportedOperationException success) {} + e = map.higherEntry(zero); + assertEquals(one, e.getKey()); + try { + e.setValue("X"); + shouldThrow(); + } catch (UnsupportedOperationException success) {} + e = map.floorEntry(one); + assertEquals(one, e.getKey()); + try { + e.setValue("X"); + shouldThrow(); + } catch (UnsupportedOperationException success) {} + e = map.ceilingEntry(five); + assertEquals(five, e.getKey()); + try { + e.setValue("X"); + shouldThrow(); + } catch (UnsupportedOperationException success) {} + } + + + + /** + * lowerKey returns preceding element + */ + public void testLowerKey() { + ConcurrentSkipListMap q = map5(); + Object e1 = q.lowerKey(three); + assertEquals(two, e1); + + Object e2 = q.lowerKey(six); + assertEquals(five, e2); + + Object e3 = q.lowerKey(one); + assertNull(e3); + + Object e4 = q.lowerKey(zero); + assertNull(e4); + } + + /** + * higherKey returns next element + */ + public void testHigherKey() { + ConcurrentSkipListMap q = map5(); + Object e1 = q.higherKey(three); + assertEquals(four, e1); + + Object e2 = q.higherKey(zero); + assertEquals(one, e2); + + Object e3 = q.higherKey(five); + assertNull(e3); + + Object e4 = q.higherKey(six); + assertNull(e4); + } + + /** + * floorKey returns preceding element + */ + public void testFloorKey() { + ConcurrentSkipListMap q = map5(); + Object e1 = q.floorKey(three); + assertEquals(three, e1); + + Object e2 = q.floorKey(six); + assertEquals(five, e2); + + Object e3 = q.floorKey(one); + assertEquals(one, e3); + + Object e4 = q.floorKey(zero); + assertNull(e4); + } + + /** + * ceilingKey returns next element + */ + public void testCeilingKey() { + ConcurrentSkipListMap q = map5(); + Object e1 = q.ceilingKey(three); + assertEquals(three, e1); + + Object e2 = q.ceilingKey(zero); + assertEquals(one, e2); + + Object e3 = q.ceilingKey(five); + assertEquals(five, e3); + + Object e4 = q.ceilingKey(six); + assertNull(e4); + } + + /** + * pollFirstEntry returns entries in order + */ + public void testPollFirstEntry() { + ConcurrentSkipListMap map = map5(); + Map.Entry e = map.pollFirstEntry(); + assertEquals(one, e.getKey()); + assertEquals("A", e.getValue()); + e = map.pollFirstEntry(); + assertEquals(two, e.getKey()); + map.put(one, "A"); + e = map.pollFirstEntry(); + assertEquals(one, e.getKey()); + assertEquals("A", e.getValue()); + e = map.pollFirstEntry(); + assertEquals(three, e.getKey()); + map.remove(four); + e = map.pollFirstEntry(); + assertEquals(five, e.getKey()); + try { + e.setValue("A"); + shouldThrow(); + } catch (UnsupportedOperationException success) {} + e = map.pollFirstEntry(); + assertNull(e); + } + + /** + * pollLastEntry returns entries in order + */ + public void testPollLastEntry() { + ConcurrentSkipListMap map = map5(); + Map.Entry e = map.pollLastEntry(); + assertEquals(five, e.getKey()); + assertEquals("E", e.getValue()); + e = map.pollLastEntry(); + assertEquals(four, e.getKey()); + map.put(five, "E"); + e = map.pollLastEntry(); + assertEquals(five, e.getKey()); + assertEquals("E", e.getValue()); + e = map.pollLastEntry(); + assertEquals(three, e.getKey()); + map.remove(two); + e = map.pollLastEntry(); + assertEquals(one, e.getKey()); + try { + e.setValue("E"); + shouldThrow(); + } catch (UnsupportedOperationException success) {} + e = map.pollLastEntry(); + assertNull(e); + } + + /** + * size returns the correct values + */ + public void testSize() { + ConcurrentSkipListMap map = map5(); + ConcurrentSkipListMap empty = new ConcurrentSkipListMap(); + assertEquals(0, empty.size()); + assertEquals(5, map.size()); + } + + /** + * toString contains toString of elements + */ + public void testToString() { + ConcurrentSkipListMap map = map5(); + String s = map.toString(); + for (int i = 1; i <= 5; ++i) { + assertTrue(s.indexOf(String.valueOf(i)) >= 0); + } + } + + // Exception tests + + /** + * get(null) of nonempty map throws NPE + */ + public void testGet_NullPointerException() { + try { + ConcurrentSkipListMap c = map5(); + c.get(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * containsKey(null) of nonempty map throws NPE + */ + public void testContainsKey_NullPointerException() { + try { + ConcurrentSkipListMap c = map5(); + c.containsKey(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * containsValue(null) throws NPE + */ + public void testContainsValue_NullPointerException() { + try { + ConcurrentSkipListMap c = new ConcurrentSkipListMap(); + c.containsValue(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + /** + * put(null,x) throws NPE + */ + public void testPut1_NullPointerException() { + try { + ConcurrentSkipListMap c = map5(); + c.put(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * putIfAbsent(null, x) throws NPE + */ + public void testPutIfAbsent1_NullPointerException() { + try { + ConcurrentSkipListMap c = map5(); + c.putIfAbsent(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * replace(null, x) throws NPE + */ + public void testReplace_NullPointerException() { + try { + ConcurrentSkipListMap c = map5(); + c.replace(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * replace(null, x, y) throws NPE + */ + public void testReplaceValue_NullPointerException() { + try { + ConcurrentSkipListMap c = map5(); + c.replace(null, one, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * remove(null) throws NPE + */ + public void testRemove1_NullPointerException() { + try { + ConcurrentSkipListMap c = new ConcurrentSkipListMap(); + c.put("sadsdf", "asdads"); + c.remove(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * remove(null, x) throws NPE + */ + public void testRemove2_NullPointerException() { + try { + ConcurrentSkipListMap c = new ConcurrentSkipListMap(); + c.put("sadsdf", "asdads"); + c.remove(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * remove(x, null) returns false + */ + public void testRemove3() { + ConcurrentSkipListMap c = new ConcurrentSkipListMap(); + c.put("sadsdf", "asdads"); + assertFalse(c.remove("sadsdf", null)); + } + + /** + * A deserialized map equals original + */ + public void testSerialization() throws Exception { + ConcurrentSkipListMap q = map5(); + + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + ConcurrentSkipListMap r = (ConcurrentSkipListMap)in.readObject(); + assertEquals(q.size(), r.size()); + assertTrue(q.equals(r)); + assertTrue(r.equals(q)); + } + + + + /** + * subMap returns map with keys in requested range + */ + public void testSubMapContents() { + ConcurrentSkipListMap map = map5(); + NavigableMap sm = map.subMap(two, true, four, false); + assertEquals(two, sm.firstKey()); + assertEquals(three, sm.lastKey()); + assertEquals(2, sm.size()); + assertFalse(sm.containsKey(one)); + assertTrue(sm.containsKey(two)); + assertTrue(sm.containsKey(three)); + assertFalse(sm.containsKey(four)); + assertFalse(sm.containsKey(five)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + assertFalse(i.hasNext()); + Iterator r = sm.descendingKeySet().iterator(); + k = (Integer)(r.next()); + assertEquals(three, k); + k = (Integer)(r.next()); + assertEquals(two, k); + assertFalse(r.hasNext()); + + Iterator j = sm.keySet().iterator(); + j.next(); + j.remove(); + assertFalse(map.containsKey(two)); + assertEquals(4, map.size()); + assertEquals(1, sm.size()); + assertEquals(three, sm.firstKey()); + assertEquals(three, sm.lastKey()); + assertEquals("C", sm.remove(three)); + assertTrue(sm.isEmpty()); + assertEquals(3, map.size()); + } + + public void testSubMapContents2() { + ConcurrentSkipListMap map = map5(); + NavigableMap sm = map.subMap(two, true, three, false); + assertEquals(1, sm.size()); + assertEquals(two, sm.firstKey()); + assertEquals(two, sm.lastKey()); + assertFalse(sm.containsKey(one)); + assertTrue(sm.containsKey(two)); + assertFalse(sm.containsKey(three)); + assertFalse(sm.containsKey(four)); + assertFalse(sm.containsKey(five)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + assertFalse(i.hasNext()); + Iterator r = sm.descendingKeySet().iterator(); + k = (Integer)(r.next()); + assertEquals(two, k); + assertFalse(r.hasNext()); + + Iterator j = sm.keySet().iterator(); + j.next(); + j.remove(); + assertFalse(map.containsKey(two)); + assertEquals(4, map.size()); + assertEquals(0, sm.size()); + assertTrue(sm.isEmpty()); + assertSame(sm.remove(three), null); + assertEquals(4, map.size()); + } + + /** + * headMap returns map with keys in requested range + */ + public void testHeadMapContents() { + ConcurrentSkipListMap map = map5(); + NavigableMap sm = map.headMap(four, false); + assertTrue(sm.containsKey(one)); + assertTrue(sm.containsKey(two)); + assertTrue(sm.containsKey(three)); + assertFalse(sm.containsKey(four)); + assertFalse(sm.containsKey(five)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(one, k); + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + assertFalse(i.hasNext()); + sm.clear(); + assertTrue(sm.isEmpty()); + assertEquals(2, map.size()); + assertEquals(four, map.firstKey()); + } + + /** + * tailMap returns map with keys in requested range + */ + public void testTailMapContents() { + ConcurrentSkipListMap map = map5(); + NavigableMap sm = map.tailMap(two, true); + assertFalse(sm.containsKey(one)); + assertTrue(sm.containsKey(two)); + assertTrue(sm.containsKey(three)); + assertTrue(sm.containsKey(four)); + assertTrue(sm.containsKey(five)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + k = (Integer)(i.next()); + assertEquals(four, k); + k = (Integer)(i.next()); + assertEquals(five, k); + assertFalse(i.hasNext()); + Iterator r = sm.descendingKeySet().iterator(); + k = (Integer)(r.next()); + assertEquals(five, k); + k = (Integer)(r.next()); + assertEquals(four, k); + k = (Integer)(r.next()); + assertEquals(three, k); + k = (Integer)(r.next()); + assertEquals(two, k); + assertFalse(r.hasNext()); + + Iterator ei = sm.entrySet().iterator(); + Map.Entry e; + e = (Map.Entry)(ei.next()); + assertEquals(two, e.getKey()); + assertEquals("B", e.getValue()); + e = (Map.Entry)(ei.next()); + assertEquals(three, e.getKey()); + assertEquals("C", e.getValue()); + e = (Map.Entry)(ei.next()); + assertEquals(four, e.getKey()); + assertEquals("D", e.getValue()); + e = (Map.Entry)(ei.next()); + assertEquals(five, e.getKey()); + assertEquals("E", e.getValue()); + assertFalse(i.hasNext()); + + NavigableMap ssm = sm.tailMap(four, true); + assertEquals(four, ssm.firstKey()); + assertEquals(five, ssm.lastKey()); + assertEquals("D", ssm.remove(four)); + assertEquals(1, ssm.size()); + assertEquals(3, sm.size()); + assertEquals(4, map.size()); + } + + Random rnd = new Random(666); + BitSet bs; + + /** + * Submaps of submaps subdivide correctly + */ + public void testRecursiveSubMaps() throws Exception { + int mapSize = 1000; + Class cl = ConcurrentSkipListMap.class; + NavigableMap<Integer, Integer> map = newMap(cl); + bs = new BitSet(mapSize); + + populate(map, mapSize); + check(map, 0, mapSize - 1, true); + check(map.descendingMap(), 0, mapSize - 1, false); + + mutateMap(map, 0, mapSize - 1); + check(map, 0, mapSize - 1, true); + check(map.descendingMap(), 0, mapSize - 1, false); + + bashSubMap(map.subMap(0, true, mapSize, false), + 0, mapSize - 1, true); + } + + static NavigableMap<Integer, Integer> newMap(Class cl) throws Exception { + NavigableMap<Integer, Integer> result = + (NavigableMap<Integer, Integer>) cl.newInstance(); + assertEquals(result.size(), 0); + assertFalse(result.keySet().iterator().hasNext()); + return result; + } + + void populate(NavigableMap<Integer, Integer> map, int limit) { + for (int i = 0, n = 2 * limit / 3; i < n; i++) { + int key = rnd.nextInt(limit); + put(map, key); + } + } + + void mutateMap(NavigableMap<Integer, Integer> map, int min, int max) { + int size = map.size(); + int rangeSize = max - min + 1; + + // Remove a bunch of entries directly + for (int i = 0, n = rangeSize / 2; i < n; i++) { + remove(map, min - 5 + rnd.nextInt(rangeSize + 10)); + } + + // Remove a bunch of entries with iterator + for (Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) { + if (rnd.nextBoolean()) { + bs.clear(it.next()); + it.remove(); + } + } + + // Add entries till we're back to original size + while (map.size() < size) { + int key = min + rnd.nextInt(rangeSize); + assertTrue(key >= min && key<= max); + put(map, key); + } + } + + void mutateSubMap(NavigableMap<Integer, Integer> map, int min, int max) { + int size = map.size(); + int rangeSize = max - min + 1; + + // Remove a bunch of entries directly + for (int i = 0, n = rangeSize / 2; i < n; i++) { + remove(map, min - 5 + rnd.nextInt(rangeSize + 10)); + } + + // Remove a bunch of entries with iterator + for (Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) { + if (rnd.nextBoolean()) { + bs.clear(it.next()); + it.remove(); + } + } + + // Add entries till we're back to original size + while (map.size() < size) { + int key = min - 5 + rnd.nextInt(rangeSize + 10); + if (key >= min && key<= max) { + put(map, key); + } else { + try { + map.put(key, 2 * key); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + } + } + + void put(NavigableMap<Integer, Integer> map, int key) { + if (map.put(key, 2 * key) == null) + bs.set(key); + } + + void remove(NavigableMap<Integer, Integer> map, int key) { + if (map.remove(key) != null) + bs.clear(key); + } + + void bashSubMap(NavigableMap<Integer, Integer> map, + int min, int max, boolean ascending) { + check(map, min, max, ascending); + check(map.descendingMap(), min, max, !ascending); + + mutateSubMap(map, min, max); + check(map, min, max, ascending); + check(map.descendingMap(), min, max, !ascending); + + // Recurse + if (max - min < 2) + return; + int midPoint = (min + max) / 2; + + // headMap - pick direction and endpoint inclusion randomly + boolean incl = rnd.nextBoolean(); + NavigableMap<Integer,Integer> hm = map.headMap(midPoint, incl); + if (ascending) { + if (rnd.nextBoolean()) + bashSubMap(hm, min, midPoint - (incl ? 0 : 1), true); + else + bashSubMap(hm.descendingMap(), min, midPoint - (incl ? 0 : 1), + false); + } else { + if (rnd.nextBoolean()) + bashSubMap(hm, midPoint + (incl ? 0 : 1), max, false); + else + bashSubMap(hm.descendingMap(), midPoint + (incl ? 0 : 1), max, + true); + } + + // tailMap - pick direction and endpoint inclusion randomly + incl = rnd.nextBoolean(); + NavigableMap<Integer,Integer> tm = map.tailMap(midPoint,incl); + if (ascending) { + if (rnd.nextBoolean()) + bashSubMap(tm, midPoint + (incl ? 0 : 1), max, true); + else + bashSubMap(tm.descendingMap(), midPoint + (incl ? 0 : 1), max, + false); + } else { + if (rnd.nextBoolean()) { + bashSubMap(tm, min, midPoint - (incl ? 0 : 1), false); + } else { + bashSubMap(tm.descendingMap(), min, midPoint - (incl ? 0 : 1), + true); + } + } + + // subMap - pick direction and endpoint inclusion randomly + int rangeSize = max - min + 1; + int[] endpoints = new int[2]; + endpoints[0] = min + rnd.nextInt(rangeSize); + endpoints[1] = min + rnd.nextInt(rangeSize); + Arrays.sort(endpoints); + boolean lowIncl = rnd.nextBoolean(); + boolean highIncl = rnd.nextBoolean(); + if (ascending) { + NavigableMap<Integer,Integer> sm = map.subMap( + endpoints[0], lowIncl, endpoints[1], highIncl); + if (rnd.nextBoolean()) + bashSubMap(sm, endpoints[0] + (lowIncl ? 0 : 1), + endpoints[1] - (highIncl ? 0 : 1), true); + else + bashSubMap(sm.descendingMap(), endpoints[0] + (lowIncl ? 0 : 1), + endpoints[1] - (highIncl ? 0 : 1), false); + } else { + NavigableMap<Integer,Integer> sm = map.subMap( + endpoints[1], highIncl, endpoints[0], lowIncl); + if (rnd.nextBoolean()) + bashSubMap(sm, endpoints[0] + (lowIncl ? 0 : 1), + endpoints[1] - (highIncl ? 0 : 1), false); + else + bashSubMap(sm.descendingMap(), endpoints[0] + (lowIncl ? 0 : 1), + endpoints[1] - (highIncl ? 0 : 1), true); + } + } + + /** + * min and max are both inclusive. If max < min, interval is empty. + */ + void check(NavigableMap<Integer, Integer> map, + final int min, final int max, final boolean ascending) { + class ReferenceSet { + int lower(int key) { + return ascending ? lowerAscending(key) : higherAscending(key); + } + int floor(int key) { + return ascending ? floorAscending(key) : ceilingAscending(key); + } + int ceiling(int key) { + return ascending ? ceilingAscending(key) : floorAscending(key); + } + int higher(int key) { + return ascending ? higherAscending(key) : lowerAscending(key); + } + int first() { + return ascending ? firstAscending() : lastAscending(); + } + int last() { + return ascending ? lastAscending() : firstAscending(); + } + int lowerAscending(int key) { + return floorAscending(key - 1); + } + int floorAscending(int key) { + if (key < min) + return -1; + else if (key > max) + key = max; + + // BitSet should support this! Test would run much faster + while (key >= min) { + if (bs.get(key)) + return(key); + key--; + } + return -1; + } + int ceilingAscending(int key) { + if (key < min) + key = min; + else if (key > max) + return -1; + int result = bs.nextSetBit(key); + return result > max ? -1 : result; + } + int higherAscending(int key) { + return ceilingAscending(key + 1); + } + private int firstAscending() { + int result = ceilingAscending(min); + return result > max ? -1 : result; + } + private int lastAscending() { + int result = floorAscending(max); + return result < min ? -1 : result; + } + } + ReferenceSet rs = new ReferenceSet(); + + // Test contents using containsKey + int size = 0; + for (int i = min; i <= max; i++) { + boolean bsContainsI = bs.get(i); + assertEquals(bsContainsI, map.containsKey(i)); + if (bsContainsI) + size++; + } + assertEquals(map.size(), size); + + // Test contents using contains keySet iterator + int size2 = 0; + int previousKey = -1; + for (int key : map.keySet()) { + assertTrue(bs.get(key)); + size2++; + assertTrue(previousKey < 0 || + (ascending ? key - previousKey > 0 : key - previousKey < 0)); + previousKey = key; + } + assertEquals(size2, size); + + // Test navigation ops + for (int key = min - 1; key <= max + 1; key++) { + assertEq(map.lowerKey(key), rs.lower(key)); + assertEq(map.floorKey(key), rs.floor(key)); + assertEq(map.higherKey(key), rs.higher(key)); + assertEq(map.ceilingKey(key), rs.ceiling(key)); + } + + // Test extrema + if (map.size() != 0) { + assertEq(map.firstKey(), rs.first()); + assertEq(map.lastKey(), rs.last()); + } else { + assertEq(rs.first(), -1); + assertEq(rs.last(), -1); + try { + map.firstKey(); + shouldThrow(); + } catch (NoSuchElementException success) {} + try { + map.lastKey(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } + } + + static void assertEq(Integer i, int j) { + if (i == null) + assertEquals(j, -1); + else + assertEquals((int) i, j); + } + + static boolean eq(Integer i, int j) { + return i == null ? j == -1 : i == j; + } + +} diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSetTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSetTest.java new file mode 100644 index 0000000..2d03b3c --- /dev/null +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSetTest.java @@ -0,0 +1,961 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + */ + +package tests.api.java.util.concurrent; // android-added + +import junit.framework.*; +import java.util.*; +import java.util.concurrent.*; +import java.io.*; + +public class ConcurrentSkipListSetTest extends JSR166TestCase { + public static Test suite() { + return new TestSuite(ConcurrentSkipListSetTest.class); + } + + static class MyReverseComparator implements Comparator { + public int compare(Object x, Object y) { + return ((Comparable)y).compareTo(x); + } + } + + /** + * Create a set of given size containing consecutive + * Integers 0 ... n. + */ + private ConcurrentSkipListSet populatedSet(int n) { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + assertTrue(q.isEmpty()); + for (int i = n-1; i >= 0; i-=2) + assertTrue(q.add(new Integer(i))); + for (int i = (n & 1); i < n; i+=2) + assertTrue(q.add(new Integer(i))); + assertFalse(q.isEmpty()); + assertEquals(n, q.size()); + return q; + } + + /** + * Create set of first 5 ints + */ + private ConcurrentSkipListSet set5() { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + assertTrue(q.isEmpty()); + q.add(one); + q.add(two); + q.add(three); + q.add(four); + q.add(five); + assertEquals(5, q.size()); + return q; + } + + /** + * A new set has unbounded capacity + */ + public void testConstructor1() { + assertEquals(0, new ConcurrentSkipListSet().size()); + } + + /** + * Initializing from null Collection throws NPE + */ + public void testConstructor3() { + try { + ConcurrentSkipListSet q = new ConcurrentSkipListSet((Collection)null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Initializing from Collection of null elements throws NPE + */ + public void testConstructor4() { + try { + Integer[] ints = new Integer[SIZE]; + ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Initializing from Collection with some null elements throws NPE + */ + public void testConstructor5() { + try { + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE-1; ++i) + ints[i] = new Integer(i); + ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Set contains all elements of collection used to initialize + */ + public void testConstructor6() { + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints)); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.pollFirst()); + } + + /** + * The comparator used in constructor is used + */ + public void testConstructor7() { + MyReverseComparator cmp = new MyReverseComparator(); + ConcurrentSkipListSet q = new ConcurrentSkipListSet(cmp); + assertEquals(cmp, q.comparator()); + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + q.addAll(Arrays.asList(ints)); + for (int i = SIZE-1; i >= 0; --i) + assertEquals(ints[i], q.pollFirst()); + } + + /** + * isEmpty is true before add, false after + */ + public void testEmpty() { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + assertTrue(q.isEmpty()); + q.add(new Integer(1)); + assertFalse(q.isEmpty()); + q.add(new Integer(2)); + q.pollFirst(); + q.pollFirst(); + assertTrue(q.isEmpty()); + } + + /** + * size changes when elements added and removed + */ + public void testSize() { + ConcurrentSkipListSet q = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(SIZE-i, q.size()); + q.pollFirst(); + } + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.size()); + q.add(new Integer(i)); + } + } + + /** + * add(null) throws NPE + */ + public void testAddNull() { + try { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + q.add(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Add of comparable element succeeds + */ + public void testAdd() { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + assertTrue(q.add(zero)); + assertTrue(q.add(one)); + } + + /** + * Add of duplicate element fails + */ + public void testAddDup() { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + assertTrue(q.add(zero)); + assertFalse(q.add(zero)); + } + + /** + * Add of non-Comparable throws CCE + */ + public void testAddNonComparable() { + try { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + q.add(new Object()); + q.add(new Object()); + q.add(new Object()); + shouldThrow(); + } catch (ClassCastException success) {} + } + + /** + * addAll(null) throws NPE + */ + public void testAddAll1() { + try { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + q.addAll(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + /** + * addAll of a collection with null elements throws NPE + */ + public void testAddAll2() { + try { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + Integer[] ints = new Integer[SIZE]; + q.addAll(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + /** + * addAll of a collection with any null elements throws NPE after + * possibly adding some elements + */ + public void testAddAll3() { + try { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE-1; ++i) + ints[i] = new Integer(i); + q.addAll(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Set contains all elements of successful addAll + */ + public void testAddAll5() { + Integer[] empty = new Integer[0]; + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(SIZE-1-i); + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + assertFalse(q.addAll(Arrays.asList(empty))); + assertTrue(q.addAll(Arrays.asList(ints))); + for (int i = 0; i < SIZE; ++i) + assertEquals(i, q.pollFirst()); + } + + /** + * pollFirst succeeds unless empty + */ + public void testPollFirst() { + ConcurrentSkipListSet q = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.pollFirst()); + } + assertNull(q.pollFirst()); + } + + /** + * pollLast succeeds unless empty + */ + public void testPollLast() { + ConcurrentSkipListSet q = populatedSet(SIZE); + for (int i = SIZE-1; i >= 0; --i) { + assertEquals(i, q.pollLast()); + } + assertNull(q.pollFirst()); + } + + + /** + * remove(x) removes x and returns true if present + */ + public void testRemoveElement() { + ConcurrentSkipListSet q = populatedSet(SIZE); + for (int i = 1; i < SIZE; i+=2) { + assertTrue(q.remove(new Integer(i))); + } + for (int i = 0; i < SIZE; i+=2) { + assertTrue(q.remove(new Integer(i))); + assertFalse(q.remove(new Integer(i+1))); + } + assertTrue(q.isEmpty()); + } + + /** + * contains(x) reports true when elements added but not yet removed + */ + public void testContains() { + ConcurrentSkipListSet q = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertTrue(q.contains(new Integer(i))); + q.pollFirst(); + assertFalse(q.contains(new Integer(i))); + } + } + + /** + * clear removes all elements + */ + public void testClear() { + ConcurrentSkipListSet q = populatedSet(SIZE); + q.clear(); + assertTrue(q.isEmpty()); + assertEquals(0, q.size()); + q.add(new Integer(1)); + assertFalse(q.isEmpty()); + q.clear(); + assertTrue(q.isEmpty()); + } + + /** + * containsAll(c) is true when c contains a subset of elements + */ + public void testContainsAll() { + ConcurrentSkipListSet q = populatedSet(SIZE); + ConcurrentSkipListSet p = new ConcurrentSkipListSet(); + for (int i = 0; i < SIZE; ++i) { + assertTrue(q.containsAll(p)); + assertFalse(p.containsAll(q)); + p.add(new Integer(i)); + } + assertTrue(p.containsAll(q)); + } + + /** + * retainAll(c) retains only those elements of c and reports true if changed + */ + public void testRetainAll() { + ConcurrentSkipListSet q = populatedSet(SIZE); + ConcurrentSkipListSet p = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + boolean changed = q.retainAll(p); + if (i == 0) + assertFalse(changed); + else + assertTrue(changed); + + assertTrue(q.containsAll(p)); + assertEquals(SIZE-i, q.size()); + p.pollFirst(); + } + } + + /** + * removeAll(c) removes only those elements of c and reports true if changed + */ + public void testRemoveAll() { + for (int i = 1; i < SIZE; ++i) { + ConcurrentSkipListSet q = populatedSet(SIZE); + ConcurrentSkipListSet p = populatedSet(i); + assertTrue(q.removeAll(p)); + assertEquals(SIZE-i, q.size()); + for (int j = 0; j < i; ++j) { + Integer I = (Integer)(p.pollFirst()); + assertFalse(q.contains(I)); + } + } + } + + + + /** + * lower returns preceding element + */ + public void testLower() { + ConcurrentSkipListSet q = set5(); + Object e1 = q.lower(three); + assertEquals(two, e1); + + Object e2 = q.lower(six); + assertEquals(five, e2); + + Object e3 = q.lower(one); + assertNull(e3); + + Object e4 = q.lower(zero); + assertNull(e4); + } + + /** + * higher returns next element + */ + public void testHigher() { + ConcurrentSkipListSet q = set5(); + Object e1 = q.higher(three); + assertEquals(four, e1); + + Object e2 = q.higher(zero); + assertEquals(one, e2); + + Object e3 = q.higher(five); + assertNull(e3); + + Object e4 = q.higher(six); + assertNull(e4); + } + + /** + * floor returns preceding element + */ + public void testFloor() { + ConcurrentSkipListSet q = set5(); + Object e1 = q.floor(three); + assertEquals(three, e1); + + Object e2 = q.floor(six); + assertEquals(five, e2); + + Object e3 = q.floor(one); + assertEquals(one, e3); + + Object e4 = q.floor(zero); + assertNull(e4); + } + + /** + * ceiling returns next element + */ + public void testCeiling() { + ConcurrentSkipListSet q = set5(); + Object e1 = q.ceiling(three); + assertEquals(three, e1); + + Object e2 = q.ceiling(zero); + assertEquals(one, e2); + + Object e3 = q.ceiling(five); + assertEquals(five, e3); + + Object e4 = q.ceiling(six); + assertNull(e4); + } + + /** + * toArray contains all elements + */ + public void testToArray() { + ConcurrentSkipListSet q = populatedSet(SIZE); + Object[] o = q.toArray(); + Arrays.sort(o); + for (int i = 0; i < o.length; i++) + assertEquals(o[i], q.pollFirst()); + } + + /** + * toArray(a) contains all elements + */ + public void testToArray2() { + ConcurrentSkipListSet q = populatedSet(SIZE); + Integer[] ints = new Integer[SIZE]; + ints = (Integer[])q.toArray(ints); + Arrays.sort(ints); + for (int i = 0; i < ints.length; i++) + assertEquals(ints[i], q.pollFirst()); + } + + /** + * iterator iterates through all elements + */ + public void testIterator() { + ConcurrentSkipListSet q = populatedSet(SIZE); + int i = 0; + Iterator it = q.iterator(); + while (it.hasNext()) { + assertTrue(q.contains(it.next())); + ++i; + } + assertEquals(i, SIZE); + } + + /** + * iterator of empty set has no elements + */ + public void testEmptyIterator() { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + int i = 0; + Iterator it = q.iterator(); + while (it.hasNext()) { + assertTrue(q.contains(it.next())); + ++i; + } + assertEquals(i, 0); + } + + /** + * iterator.remove removes current element + */ + public void testIteratorRemove () { + final ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + q.add(new Integer(2)); + q.add(new Integer(1)); + q.add(new Integer(3)); + + Iterator it = q.iterator(); + it.next(); + it.remove(); + + it = q.iterator(); + assertEquals(it.next(), new Integer(2)); + assertEquals(it.next(), new Integer(3)); + assertFalse(it.hasNext()); + } + + + /** + * toString contains toStrings of elements + */ + public void testToString() { + ConcurrentSkipListSet q = populatedSet(SIZE); + String s = q.toString(); + for (int i = 0; i < SIZE; ++i) { + assertTrue(s.indexOf(String.valueOf(i)) >= 0); + } + } + + /** + * A deserialized serialized set has same elements + */ + public void testSerialization() throws Exception { + ConcurrentSkipListSet q = populatedSet(SIZE); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + ConcurrentSkipListSet r = (ConcurrentSkipListSet)in.readObject(); + assertEquals(q.size(), r.size()); + while (!q.isEmpty()) + assertEquals(q.pollFirst(), r.pollFirst()); + } + + /** + * subSet returns set with keys in requested range + */ + public void testSubSetContents() { + ConcurrentSkipListSet set = set5(); + SortedSet sm = set.subSet(two, four); + assertEquals(two, sm.first()); + assertEquals(three, sm.last()); + assertEquals(2, sm.size()); + assertFalse(sm.contains(one)); + assertTrue(sm.contains(two)); + assertTrue(sm.contains(three)); + assertFalse(sm.contains(four)); + assertFalse(sm.contains(five)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + assertFalse(i.hasNext()); + Iterator j = sm.iterator(); + j.next(); + j.remove(); + assertFalse(set.contains(two)); + assertEquals(4, set.size()); + assertEquals(1, sm.size()); + assertEquals(three, sm.first()); + assertEquals(three, sm.last()); + assertTrue(sm.remove(three)); + assertTrue(sm.isEmpty()); + assertEquals(3, set.size()); + } + + public void testSubSetContents2() { + ConcurrentSkipListSet set = set5(); + SortedSet sm = set.subSet(two, three); + assertEquals(1, sm.size()); + assertEquals(two, sm.first()); + assertEquals(two, sm.last()); + assertFalse(sm.contains(one)); + assertTrue(sm.contains(two)); + assertFalse(sm.contains(three)); + assertFalse(sm.contains(four)); + assertFalse(sm.contains(five)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + assertFalse(i.hasNext()); + Iterator j = sm.iterator(); + j.next(); + j.remove(); + assertFalse(set.contains(two)); + assertEquals(4, set.size()); + assertEquals(0, sm.size()); + assertTrue(sm.isEmpty()); + assertFalse(sm.remove(three)); + assertEquals(4, set.size()); + } + + /** + * headSet returns set with keys in requested range + */ + public void testHeadSetContents() { + ConcurrentSkipListSet set = set5(); + SortedSet sm = set.headSet(four); + assertTrue(sm.contains(one)); + assertTrue(sm.contains(two)); + assertTrue(sm.contains(three)); + assertFalse(sm.contains(four)); + assertFalse(sm.contains(five)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(one, k); + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + assertFalse(i.hasNext()); + sm.clear(); + assertTrue(sm.isEmpty()); + assertEquals(2, set.size()); + assertEquals(four, set.first()); + } + + /** + * tailSet returns set with keys in requested range + */ + public void testTailSetContents() { + ConcurrentSkipListSet set = set5(); + SortedSet sm = set.tailSet(two); + assertFalse(sm.contains(one)); + assertTrue(sm.contains(two)); + assertTrue(sm.contains(three)); + assertTrue(sm.contains(four)); + assertTrue(sm.contains(five)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + k = (Integer)(i.next()); + assertEquals(four, k); + k = (Integer)(i.next()); + assertEquals(five, k); + assertFalse(i.hasNext()); + + SortedSet ssm = sm.tailSet(four); + assertEquals(four, ssm.first()); + assertEquals(five, ssm.last()); + assertTrue(ssm.remove(four)); + assertEquals(1, ssm.size()); + assertEquals(3, sm.size()); + assertEquals(4, set.size()); + } + + Random rnd = new Random(666); + BitSet bs; + + /** + * Subsets of subsets subdivide correctly + */ + public void testRecursiveSubSets() throws Exception { + int setSize = 1000; + Class cl = ConcurrentSkipListSet.class; + + NavigableSet<Integer> set = newSet(cl); + bs = new BitSet(setSize); + + populate(set, setSize); + check(set, 0, setSize - 1, true); + check(set.descendingSet(), 0, setSize - 1, false); + + mutateSet(set, 0, setSize - 1); + check(set, 0, setSize - 1, true); + check(set.descendingSet(), 0, setSize - 1, false); + + bashSubSet(set.subSet(0, true, setSize, false), + 0, setSize - 1, true); + } + + static NavigableSet<Integer> newSet(Class cl) throws Exception { + NavigableSet<Integer> result = (NavigableSet<Integer>) cl.newInstance(); + assertEquals(result.size(), 0); + assertFalse(result.iterator().hasNext()); + return result; + } + + void populate(NavigableSet<Integer> set, int limit) { + for (int i = 0, n = 2 * limit / 3; i < n; i++) { + int element = rnd.nextInt(limit); + put(set, element); + } + } + + void mutateSet(NavigableSet<Integer> set, int min, int max) { + int size = set.size(); + int rangeSize = max - min + 1; + + // Remove a bunch of entries directly + for (int i = 0, n = rangeSize / 2; i < n; i++) { + remove(set, min - 5 + rnd.nextInt(rangeSize + 10)); + } + + // Remove a bunch of entries with iterator + for (Iterator<Integer> it = set.iterator(); it.hasNext(); ) { + if (rnd.nextBoolean()) { + bs.clear(it.next()); + it.remove(); + } + } + + // Add entries till we're back to original size + while (set.size() < size) { + int element = min + rnd.nextInt(rangeSize); + assertTrue(element >= min && element<= max); + put(set, element); + } + } + + void mutateSubSet(NavigableSet<Integer> set, int min, int max) { + int size = set.size(); + int rangeSize = max - min + 1; + + // Remove a bunch of entries directly + for (int i = 0, n = rangeSize / 2; i < n; i++) { + remove(set, min - 5 + rnd.nextInt(rangeSize + 10)); + } + + // Remove a bunch of entries with iterator + for (Iterator<Integer> it = set.iterator(); it.hasNext(); ) { + if (rnd.nextBoolean()) { + bs.clear(it.next()); + it.remove(); + } + } + + // Add entries till we're back to original size + while (set.size() < size) { + int element = min - 5 + rnd.nextInt(rangeSize + 10); + if (element >= min && element<= max) { + put(set, element); + } else { + try { + set.add(element); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + } + } + + void put(NavigableSet<Integer> set, int element) { + if (set.add(element)) + bs.set(element); + } + + void remove(NavigableSet<Integer> set, int element) { + if (set.remove(element)) + bs.clear(element); + } + + void bashSubSet(NavigableSet<Integer> set, + int min, int max, boolean ascending) { + check(set, min, max, ascending); + check(set.descendingSet(), min, max, !ascending); + + mutateSubSet(set, min, max); + check(set, min, max, ascending); + check(set.descendingSet(), min, max, !ascending); + + // Recurse + if (max - min < 2) + return; + int midPoint = (min + max) / 2; + + // headSet - pick direction and endpoint inclusion randomly + boolean incl = rnd.nextBoolean(); + NavigableSet<Integer> hm = set.headSet(midPoint, incl); + if (ascending) { + if (rnd.nextBoolean()) + bashSubSet(hm, min, midPoint - (incl ? 0 : 1), true); + else + bashSubSet(hm.descendingSet(), min, midPoint - (incl ? 0 : 1), + false); + } else { + if (rnd.nextBoolean()) + bashSubSet(hm, midPoint + (incl ? 0 : 1), max, false); + else + bashSubSet(hm.descendingSet(), midPoint + (incl ? 0 : 1), max, + true); + } + + // tailSet - pick direction and endpoint inclusion randomly + incl = rnd.nextBoolean(); + NavigableSet<Integer> tm = set.tailSet(midPoint,incl); + if (ascending) { + if (rnd.nextBoolean()) + bashSubSet(tm, midPoint + (incl ? 0 : 1), max, true); + else + bashSubSet(tm.descendingSet(), midPoint + (incl ? 0 : 1), max, + false); + } else { + if (rnd.nextBoolean()) { + bashSubSet(tm, min, midPoint - (incl ? 0 : 1), false); + } else { + bashSubSet(tm.descendingSet(), min, midPoint - (incl ? 0 : 1), + true); + } + } + + // subSet - pick direction and endpoint inclusion randomly + int rangeSize = max - min + 1; + int[] endpoints = new int[2]; + endpoints[0] = min + rnd.nextInt(rangeSize); + endpoints[1] = min + rnd.nextInt(rangeSize); + Arrays.sort(endpoints); + boolean lowIncl = rnd.nextBoolean(); + boolean highIncl = rnd.nextBoolean(); + if (ascending) { + NavigableSet<Integer> sm = set.subSet( + endpoints[0], lowIncl, endpoints[1], highIncl); + if (rnd.nextBoolean()) + bashSubSet(sm, endpoints[0] + (lowIncl ? 0 : 1), + endpoints[1] - (highIncl ? 0 : 1), true); + else + bashSubSet(sm.descendingSet(), endpoints[0] + (lowIncl ? 0 : 1), + endpoints[1] - (highIncl ? 0 : 1), false); + } else { + NavigableSet<Integer> sm = set.subSet( + endpoints[1], highIncl, endpoints[0], lowIncl); + if (rnd.nextBoolean()) + bashSubSet(sm, endpoints[0] + (lowIncl ? 0 : 1), + endpoints[1] - (highIncl ? 0 : 1), false); + else + bashSubSet(sm.descendingSet(), endpoints[0] + (lowIncl ? 0 : 1), + endpoints[1] - (highIncl ? 0 : 1), true); + } + } + + /** + * min and max are both inclusive. If max < min, interval is empty. + */ + void check(NavigableSet<Integer> set, + final int min, final int max, final boolean ascending) { + class ReferenceSet { + int lower(int element) { + return ascending ? + lowerAscending(element) : higherAscending(element); + } + int floor(int element) { + return ascending ? + floorAscending(element) : ceilingAscending(element); + } + int ceiling(int element) { + return ascending ? + ceilingAscending(element) : floorAscending(element); + } + int higher(int element) { + return ascending ? + higherAscending(element) : lowerAscending(element); + } + int first() { + return ascending ? firstAscending() : lastAscending(); + } + int last() { + return ascending ? lastAscending() : firstAscending(); + } + int lowerAscending(int element) { + return floorAscending(element - 1); + } + int floorAscending(int element) { + if (element < min) + return -1; + else if (element > max) + element = max; + + // BitSet should support this! Test would run much faster + while (element >= min) { + if (bs.get(element)) + return(element); + element--; + } + return -1; + } + int ceilingAscending(int element) { + if (element < min) + element = min; + else if (element > max) + return -1; + int result = bs.nextSetBit(element); + return result > max ? -1 : result; + } + int higherAscending(int element) { + return ceilingAscending(element + 1); + } + private int firstAscending() { + int result = ceilingAscending(min); + return result > max ? -1 : result; + } + private int lastAscending() { + int result = floorAscending(max); + return result < min ? -1 : result; + } + } + ReferenceSet rs = new ReferenceSet(); + + // Test contents using containsElement + int size = 0; + for (int i = min; i <= max; i++) { + boolean bsContainsI = bs.get(i); + assertEquals(bsContainsI, set.contains(i)); + if (bsContainsI) + size++; + } + assertEquals(set.size(), size); + + // Test contents using contains elementSet iterator + int size2 = 0; + int previousElement = -1; + for (int element : set) { + assertTrue(bs.get(element)); + size2++; + assertTrue(previousElement < 0 || (ascending ? + element - previousElement > 0 : element - previousElement < 0)); + previousElement = element; + } + assertEquals(size2, size); + + // Test navigation ops + for (int element = min - 1; element <= max + 1; element++) { + assertEq(set.lower(element), rs.lower(element)); + assertEq(set.floor(element), rs.floor(element)); + assertEq(set.higher(element), rs.higher(element)); + assertEq(set.ceiling(element), rs.ceiling(element)); + } + + // Test extrema + if (set.size() != 0) { + assertEq(set.first(), rs.first()); + assertEq(set.last(), rs.last()); + } else { + assertEq(rs.first(), -1); + assertEq(rs.last(), -1); + try { + set.first(); + shouldThrow(); + } catch (NoSuchElementException success) {} + try { + set.last(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } + } + + static void assertEq(Integer i, int j) { + if (i == null) + assertEquals(j, -1); + else + assertEquals((int) i, j); + } + + static boolean eq(Integer i, int j) { + return i == null ? j == -1 : i == j; + } + +} diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSubMapTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSubMapTest.java new file mode 100644 index 0000000..fc70935 --- /dev/null +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSubMapTest.java @@ -0,0 +1,1438 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + */ + +package tests.api.java.util.concurrent; // android-added + +import junit.framework.*; +import java.util.*; +import java.util.concurrent.*; +import java.io.*; + +public class ConcurrentSkipListSubMapTest extends JSR166TestCase { + public static Test suite() { + return new TestSuite(ConcurrentSkipListSubMapTest.class); + } + + /** + * Create a map from Integers 1-5 to Strings "A"-"E". + */ + private static ConcurrentNavigableMap map5() { + ConcurrentSkipListMap map = new ConcurrentSkipListMap(); + assertTrue(map.isEmpty()); + map.put(zero, "Z"); + map.put(one, "A"); + map.put(five, "E"); + map.put(three, "C"); + map.put(two, "B"); + map.put(four, "D"); + map.put(seven, "F"); + assertFalse(map.isEmpty()); + assertEquals(7, map.size()); + return map.subMap(one, true, seven, false); + } + + /** + * Create a map from Integers -5 to -1 to Strings "A"-"E". + */ + private static ConcurrentNavigableMap dmap5() { + ConcurrentSkipListMap map = new ConcurrentSkipListMap(); + assertTrue(map.isEmpty()); + map.put(m1, "A"); + map.put(m5, "E"); + map.put(m3, "C"); + map.put(m2, "B"); + map.put(m4, "D"); + assertFalse(map.isEmpty()); + assertEquals(5, map.size()); + return map.descendingMap(); + } + + private static ConcurrentNavigableMap map0() { + ConcurrentSkipListMap map = new ConcurrentSkipListMap(); + assertTrue(map.isEmpty()); + return map.tailMap(one, true); + } + + private static ConcurrentNavigableMap dmap0() { + ConcurrentSkipListMap map = new ConcurrentSkipListMap(); + assertTrue(map.isEmpty()); + return map; + } + + /** + * clear removes all pairs + */ + public void testClear() { + ConcurrentNavigableMap map = map5(); + map.clear(); + assertEquals(map.size(), 0); + } + + + /** + * Maps with same contents are equal + */ + public void testEquals() { + ConcurrentNavigableMap map1 = map5(); + ConcurrentNavigableMap map2 = map5(); + assertEquals(map1, map2); + assertEquals(map2, map1); + map1.clear(); + assertFalse(map1.equals(map2)); + assertFalse(map2.equals(map1)); + } + + /** + * containsKey returns true for contained key + */ + public void testContainsKey() { + ConcurrentNavigableMap map = map5(); + assertTrue(map.containsKey(one)); + assertFalse(map.containsKey(zero)); + } + + /** + * containsValue returns true for held values + */ + public void testContainsValue() { + ConcurrentNavigableMap map = map5(); + assertTrue(map.containsValue("A")); + assertFalse(map.containsValue("Z")); + } + + /** + * get returns the correct element at the given key, + * or null if not present + */ + public void testGet() { + ConcurrentNavigableMap map = map5(); + assertEquals("A", (String)map.get(one)); + ConcurrentNavigableMap empty = map0(); + assertNull(empty.get(one)); + } + + /** + * isEmpty is true of empty map and false for non-empty + */ + public void testIsEmpty() { + ConcurrentNavigableMap empty = map0(); + ConcurrentNavigableMap map = map5(); + assertTrue(empty.isEmpty()); + assertFalse(map.isEmpty()); + } + + /** + * firstKey returns first key + */ + public void testFirstKey() { + ConcurrentNavigableMap map = map5(); + assertEquals(one, map.firstKey()); + } + + /** + * lastKey returns last key + */ + public void testLastKey() { + ConcurrentNavigableMap map = map5(); + assertEquals(five, map.lastKey()); + } + + + /** + * keySet returns a Set containing all the keys + */ + public void testKeySet() { + ConcurrentNavigableMap map = map5(); + Set s = map.keySet(); + assertEquals(5, s.size()); + assertTrue(s.contains(one)); + assertTrue(s.contains(two)); + assertTrue(s.contains(three)); + assertTrue(s.contains(four)); + assertTrue(s.contains(five)); + } + + /** + * keySet is ordered + */ + public void testKeySetOrder() { + ConcurrentNavigableMap map = map5(); + Set s = map.keySet(); + Iterator i = s.iterator(); + Integer last = (Integer)i.next(); + assertEquals(last, one); + while (i.hasNext()) { + Integer k = (Integer)i.next(); + assertTrue(last.compareTo(k) < 0); + last = k; + } + } + + /** + * values collection contains all values + */ + public void testValues() { + ConcurrentNavigableMap map = map5(); + Collection s = map.values(); + assertEquals(5, s.size()); + assertTrue(s.contains("A")); + assertTrue(s.contains("B")); + assertTrue(s.contains("C")); + assertTrue(s.contains("D")); + assertTrue(s.contains("E")); + } + + /** + * keySet.toArray returns contains all keys + */ + public void testKeySetToArray() { + ConcurrentNavigableMap map = map5(); + Set s = map.keySet(); + Object[] ar = s.toArray(); + assertTrue(s.containsAll(Arrays.asList(ar))); + assertEquals(5, ar.length); + ar[0] = m10; + assertFalse(s.containsAll(Arrays.asList(ar))); + } + + /** + * descendingkeySet.toArray returns contains all keys + */ + public void testDescendingKeySetToArray() { + ConcurrentNavigableMap map = map5(); + Set s = map.descendingKeySet(); + Object[] ar = s.toArray(); + assertEquals(5, ar.length); + assertTrue(s.containsAll(Arrays.asList(ar))); + ar[0] = m10; + assertFalse(s.containsAll(Arrays.asList(ar))); + } + + /** + * Values.toArray contains all values + */ + public void testValuesToArray() { + ConcurrentNavigableMap map = map5(); + Collection v = map.values(); + Object[] ar = v.toArray(); + ArrayList s = new ArrayList(Arrays.asList(ar)); + assertEquals(5, ar.length); + assertTrue(s.contains("A")); + assertTrue(s.contains("B")); + assertTrue(s.contains("C")); + assertTrue(s.contains("D")); + assertTrue(s.contains("E")); + } + + + /** + * entrySet contains all pairs + */ + public void testEntrySet() { + ConcurrentNavigableMap map = map5(); + Set s = map.entrySet(); + assertEquals(5, s.size()); + Iterator it = s.iterator(); + while (it.hasNext()) { + Map.Entry e = (Map.Entry) it.next(); + assertTrue( + (e.getKey().equals(one) && e.getValue().equals("A")) || + (e.getKey().equals(two) && e.getValue().equals("B")) || + (e.getKey().equals(three) && e.getValue().equals("C")) || + (e.getKey().equals(four) && e.getValue().equals("D")) || + (e.getKey().equals(five) && e.getValue().equals("E"))); + } + } + + /** + * putAll adds all key-value pairs from the given map + */ + public void testPutAll() { + ConcurrentNavigableMap empty = map0(); + ConcurrentNavigableMap map = map5(); + empty.putAll(map); + assertEquals(5, empty.size()); + assertTrue(empty.containsKey(one)); + assertTrue(empty.containsKey(two)); + assertTrue(empty.containsKey(three)); + assertTrue(empty.containsKey(four)); + assertTrue(empty.containsKey(five)); + } + + /** + * putIfAbsent works when the given key is not present + */ + public void testPutIfAbsent() { + ConcurrentNavigableMap map = map5(); + map.putIfAbsent(six, "Z"); + assertTrue(map.containsKey(six)); + } + + /** + * putIfAbsent does not add the pair if the key is already present + */ + public void testPutIfAbsent2() { + ConcurrentNavigableMap map = map5(); + assertEquals("A", map.putIfAbsent(one, "Z")); + } + + /** + * replace fails when the given key is not present + */ + public void testReplace() { + ConcurrentNavigableMap map = map5(); + assertNull(map.replace(six, "Z")); + assertFalse(map.containsKey(six)); + } + + /** + * replace succeeds if the key is already present + */ + public void testReplace2() { + ConcurrentNavigableMap map = map5(); + assertNotNull(map.replace(one, "Z")); + assertEquals("Z", map.get(one)); + } + + + /** + * replace value fails when the given key not mapped to expected value + */ + public void testReplaceValue() { + ConcurrentNavigableMap map = map5(); + assertEquals("A", map.get(one)); + assertFalse(map.replace(one, "Z", "Z")); + assertEquals("A", map.get(one)); + } + + /** + * replace value succeeds when the given key mapped to expected value + */ + public void testReplaceValue2() { + ConcurrentNavigableMap map = map5(); + assertEquals("A", map.get(one)); + assertTrue(map.replace(one, "A", "Z")); + assertEquals("Z", map.get(one)); + } + + + /** + * remove removes the correct key-value pair from the map + */ + public void testRemove() { + ConcurrentNavigableMap map = map5(); + map.remove(five); + assertEquals(4, map.size()); + assertFalse(map.containsKey(five)); + } + + /** + * remove(key,value) removes only if pair present + */ + public void testRemove2() { + ConcurrentNavigableMap map = map5(); + assertTrue(map.containsKey(five)); + assertEquals("E", map.get(five)); + map.remove(five, "E"); + assertEquals(4, map.size()); + assertFalse(map.containsKey(five)); + map.remove(four, "A"); + assertEquals(4, map.size()); + assertTrue(map.containsKey(four)); + } + + /** + * lowerEntry returns preceding entry. + */ + public void testLowerEntry() { + ConcurrentNavigableMap map = map5(); + Map.Entry e1 = map.lowerEntry(three); + assertEquals(two, e1.getKey()); + + Map.Entry e2 = map.lowerEntry(six); + assertEquals(five, e2.getKey()); + + Map.Entry e3 = map.lowerEntry(one); + assertNull(e3); + + Map.Entry e4 = map.lowerEntry(zero); + assertNull(e4); + } + + /** + * higherEntry returns next entry. + */ + public void testHigherEntry() { + ConcurrentNavigableMap map = map5(); + Map.Entry e1 = map.higherEntry(three); + assertEquals(four, e1.getKey()); + + Map.Entry e2 = map.higherEntry(zero); + assertEquals(one, e2.getKey()); + + Map.Entry e3 = map.higherEntry(five); + assertNull(e3); + + Map.Entry e4 = map.higherEntry(six); + assertNull(e4); + } + + /** + * floorEntry returns preceding entry. + */ + public void testFloorEntry() { + ConcurrentNavigableMap map = map5(); + Map.Entry e1 = map.floorEntry(three); + assertEquals(three, e1.getKey()); + + Map.Entry e2 = map.floorEntry(six); + assertEquals(five, e2.getKey()); + + Map.Entry e3 = map.floorEntry(one); + assertEquals(one, e3.getKey()); + + Map.Entry e4 = map.floorEntry(zero); + assertNull(e4); + } + + /** + * ceilingEntry returns next entry. + */ + public void testCeilingEntry() { + ConcurrentNavigableMap map = map5(); + Map.Entry e1 = map.ceilingEntry(three); + assertEquals(three, e1.getKey()); + + Map.Entry e2 = map.ceilingEntry(zero); + assertEquals(one, e2.getKey()); + + Map.Entry e3 = map.ceilingEntry(five); + assertEquals(five, e3.getKey()); + + Map.Entry e4 = map.ceilingEntry(six); + assertNull(e4); + } + + /** + * pollFirstEntry returns entries in order + */ + public void testPollFirstEntry() { + ConcurrentNavigableMap map = map5(); + Map.Entry e = map.pollFirstEntry(); + assertEquals(one, e.getKey()); + assertEquals("A", e.getValue()); + e = map.pollFirstEntry(); + assertEquals(two, e.getKey()); + map.put(one, "A"); + e = map.pollFirstEntry(); + assertEquals(one, e.getKey()); + assertEquals("A", e.getValue()); + e = map.pollFirstEntry(); + assertEquals(three, e.getKey()); + map.remove(four); + e = map.pollFirstEntry(); + assertEquals(five, e.getKey()); + try { + e.setValue("A"); + shouldThrow(); + } catch (UnsupportedOperationException success) {} + e = map.pollFirstEntry(); + assertNull(e); + } + + /** + * pollLastEntry returns entries in order + */ + public void testPollLastEntry() { + ConcurrentNavigableMap map = map5(); + Map.Entry e = map.pollLastEntry(); + assertEquals(five, e.getKey()); + assertEquals("E", e.getValue()); + e = map.pollLastEntry(); + assertEquals(four, e.getKey()); + map.put(five, "E"); + e = map.pollLastEntry(); + assertEquals(five, e.getKey()); + assertEquals("E", e.getValue()); + e = map.pollLastEntry(); + assertEquals(three, e.getKey()); + map.remove(two); + e = map.pollLastEntry(); + assertEquals(one, e.getKey()); + try { + e.setValue("E"); + shouldThrow(); + } catch (UnsupportedOperationException success) {} + e = map.pollLastEntry(); + assertNull(e); + } + + /** + * size returns the correct values + */ + public void testSize() { + ConcurrentNavigableMap map = map5(); + ConcurrentNavigableMap empty = map0(); + assertEquals(0, empty.size()); + assertEquals(5, map.size()); + } + + /** + * toString contains toString of elements + */ + public void testToString() { + ConcurrentNavigableMap map = map5(); + String s = map.toString(); + for (int i = 1; i <= 5; ++i) { + assertTrue(s.indexOf(String.valueOf(i)) >= 0); + } + } + + // Exception tests + + /** + * get(null) of nonempty map throws NPE + */ + public void testGet_NullPointerException() { + try { + ConcurrentNavigableMap c = map5(); + c.get(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * containsKey(null) of nonempty map throws NPE + */ + public void testContainsKey_NullPointerException() { + try { + ConcurrentNavigableMap c = map5(); + c.containsKey(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * containsValue(null) throws NPE + */ + public void testContainsValue_NullPointerException() { + try { + ConcurrentNavigableMap c = map0(); + c.containsValue(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + /** + * put(null,x) throws NPE + */ + public void testPut1_NullPointerException() { + try { + ConcurrentNavigableMap c = map5(); + c.put(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * putIfAbsent(null, x) throws NPE + */ + public void testPutIfAbsent1_NullPointerException() { + try { + ConcurrentNavigableMap c = map5(); + c.putIfAbsent(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * replace(null, x) throws NPE + */ + public void testReplace_NullPointerException() { + try { + ConcurrentNavigableMap c = map5(); + c.replace(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * replace(null, x, y) throws NPE + */ + public void testReplaceValue_NullPointerException() { + try { + ConcurrentNavigableMap c = map5(); + c.replace(null, one, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * remove(null) throws NPE + */ + public void testRemove1_NullPointerException() { + try { + ConcurrentNavigableMap c = map5(); + c.remove(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * remove(null, x) throws NPE + */ + public void testRemove2_NullPointerException() { + try { + ConcurrentNavigableMap c = map5(); + c.remove(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * A deserialized map equals original + */ + public void testSerialization() throws Exception { + ConcurrentNavigableMap q = map5(); + + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + ConcurrentNavigableMap r = (ConcurrentNavigableMap)in.readObject(); + assertEquals(q.size(), r.size()); + assertTrue(q.equals(r)); + assertTrue(r.equals(q)); + } + + + + /** + * subMap returns map with keys in requested range + */ + public void testSubMapContents() { + ConcurrentNavigableMap map = map5(); + SortedMap sm = map.subMap(two, four); + assertEquals(two, sm.firstKey()); + assertEquals(three, sm.lastKey()); + assertEquals(2, sm.size()); + assertFalse(sm.containsKey(one)); + assertTrue(sm.containsKey(two)); + assertTrue(sm.containsKey(three)); + assertFalse(sm.containsKey(four)); + assertFalse(sm.containsKey(five)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + assertFalse(i.hasNext()); + Iterator j = sm.keySet().iterator(); + j.next(); + j.remove(); + assertFalse(map.containsKey(two)); + assertEquals(4, map.size()); + assertEquals(1, sm.size()); + assertEquals(three, sm.firstKey()); + assertEquals(three, sm.lastKey()); + assertEquals("C", sm.remove(three)); + assertTrue(sm.isEmpty()); + assertEquals(3, map.size()); + } + + public void testSubMapContents2() { + ConcurrentNavigableMap map = map5(); + SortedMap sm = map.subMap(two, three); + assertEquals(1, sm.size()); + assertEquals(two, sm.firstKey()); + assertEquals(two, sm.lastKey()); + assertFalse(sm.containsKey(one)); + assertTrue(sm.containsKey(two)); + assertFalse(sm.containsKey(three)); + assertFalse(sm.containsKey(four)); + assertFalse(sm.containsKey(five)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + assertFalse(i.hasNext()); + Iterator j = sm.keySet().iterator(); + j.next(); + j.remove(); + assertFalse(map.containsKey(two)); + assertEquals(4, map.size()); + assertEquals(0, sm.size()); + assertTrue(sm.isEmpty()); + assertSame(sm.remove(three), null); + assertEquals(4, map.size()); + } + + /** + * headMap returns map with keys in requested range + */ + public void testHeadMapContents() { + ConcurrentNavigableMap map = map5(); + SortedMap sm = map.headMap(four); + assertTrue(sm.containsKey(one)); + assertTrue(sm.containsKey(two)); + assertTrue(sm.containsKey(three)); + assertFalse(sm.containsKey(four)); + assertFalse(sm.containsKey(five)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(one, k); + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + assertFalse(i.hasNext()); + sm.clear(); + assertTrue(sm.isEmpty()); + assertEquals(2, map.size()); + assertEquals(four, map.firstKey()); + } + + /** + * headMap returns map with keys in requested range + */ + public void testTailMapContents() { + ConcurrentNavigableMap map = map5(); + SortedMap sm = map.tailMap(two); + assertFalse(sm.containsKey(one)); + assertTrue(sm.containsKey(two)); + assertTrue(sm.containsKey(three)); + assertTrue(sm.containsKey(four)); + assertTrue(sm.containsKey(five)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + k = (Integer)(i.next()); + assertEquals(four, k); + k = (Integer)(i.next()); + assertEquals(five, k); + assertFalse(i.hasNext()); + + Iterator ei = sm.entrySet().iterator(); + Map.Entry e; + e = (Map.Entry)(ei.next()); + assertEquals(two, e.getKey()); + assertEquals("B", e.getValue()); + e = (Map.Entry)(ei.next()); + assertEquals(three, e.getKey()); + assertEquals("C", e.getValue()); + e = (Map.Entry)(ei.next()); + assertEquals(four, e.getKey()); + assertEquals("D", e.getValue()); + e = (Map.Entry)(ei.next()); + assertEquals(five, e.getKey()); + assertEquals("E", e.getValue()); + assertFalse(i.hasNext()); + + SortedMap ssm = sm.tailMap(four); + assertEquals(four, ssm.firstKey()); + assertEquals(five, ssm.lastKey()); + assertEquals("D", ssm.remove(four)); + assertEquals(1, ssm.size()); + assertEquals(3, sm.size()); + assertEquals(4, map.size()); + } + + /** + * clear removes all pairs + */ + public void testDescendingClear() { + ConcurrentNavigableMap map = dmap5(); + map.clear(); + assertEquals(map.size(), 0); + } + + + /** + * Maps with same contents are equal + */ + public void testDescendingEquals() { + ConcurrentNavigableMap map1 = dmap5(); + ConcurrentNavigableMap map2 = dmap5(); + assertEquals(map1, map2); + assertEquals(map2, map1); + map1.clear(); + assertFalse(map1.equals(map2)); + assertFalse(map2.equals(map1)); + } + + /** + * containsKey returns true for contained key + */ + public void testDescendingContainsKey() { + ConcurrentNavigableMap map = dmap5(); + assertTrue(map.containsKey(m1)); + assertFalse(map.containsKey(zero)); + } + + /** + * containsValue returns true for held values + */ + public void testDescendingContainsValue() { + ConcurrentNavigableMap map = dmap5(); + assertTrue(map.containsValue("A")); + assertFalse(map.containsValue("Z")); + } + + /** + * get returns the correct element at the given key, + * or null if not present + */ + public void testDescendingGet() { + ConcurrentNavigableMap map = dmap5(); + assertEquals("A", (String)map.get(m1)); + ConcurrentNavigableMap empty = dmap0(); + assertNull(empty.get(m1)); + } + + /** + * isEmpty is true of empty map and false for non-empty + */ + public void testDescendingIsEmpty() { + ConcurrentNavigableMap empty = dmap0(); + ConcurrentNavigableMap map = dmap5(); + assertTrue(empty.isEmpty()); + assertFalse(map.isEmpty()); + } + + /** + * firstKey returns first key + */ + public void testDescendingFirstKey() { + ConcurrentNavigableMap map = dmap5(); + assertEquals(m1, map.firstKey()); + } + + /** + * lastKey returns last key + */ + public void testDescendingLastKey() { + ConcurrentNavigableMap map = dmap5(); + assertEquals(m5, map.lastKey()); + } + + + /** + * keySet returns a Set containing all the keys + */ + public void testDescendingKeySet() { + ConcurrentNavigableMap map = dmap5(); + Set s = map.keySet(); + assertEquals(5, s.size()); + assertTrue(s.contains(m1)); + assertTrue(s.contains(m2)); + assertTrue(s.contains(m3)); + assertTrue(s.contains(m4)); + assertTrue(s.contains(m5)); + } + + /** + * keySet is ordered + */ + public void testDescendingKeySetOrder() { + ConcurrentNavigableMap map = dmap5(); + Set s = map.keySet(); + Iterator i = s.iterator(); + Integer last = (Integer)i.next(); + assertEquals(last, m1); + while (i.hasNext()) { + Integer k = (Integer)i.next(); + assertTrue(last.compareTo(k) > 0); + last = k; + } + } + + /** + * values collection contains all values + */ + public void testDescendingValues() { + ConcurrentNavigableMap map = dmap5(); + Collection s = map.values(); + assertEquals(5, s.size()); + assertTrue(s.contains("A")); + assertTrue(s.contains("B")); + assertTrue(s.contains("C")); + assertTrue(s.contains("D")); + assertTrue(s.contains("E")); + } + + /** + * keySet.toArray returns contains all keys + */ + public void testDescendingAscendingKeySetToArray() { + ConcurrentNavigableMap map = dmap5(); + Set s = map.keySet(); + Object[] ar = s.toArray(); + assertTrue(s.containsAll(Arrays.asList(ar))); + assertEquals(5, ar.length); + ar[0] = m10; + assertFalse(s.containsAll(Arrays.asList(ar))); + } + + /** + * descendingkeySet.toArray returns contains all keys + */ + public void testDescendingDescendingKeySetToArray() { + ConcurrentNavigableMap map = dmap5(); + Set s = map.descendingKeySet(); + Object[] ar = s.toArray(); + assertEquals(5, ar.length); + assertTrue(s.containsAll(Arrays.asList(ar))); + ar[0] = m10; + assertFalse(s.containsAll(Arrays.asList(ar))); + } + + /** + * Values.toArray contains all values + */ + public void testDescendingValuesToArray() { + ConcurrentNavigableMap map = dmap5(); + Collection v = map.values(); + Object[] ar = v.toArray(); + ArrayList s = new ArrayList(Arrays.asList(ar)); + assertEquals(5, ar.length); + assertTrue(s.contains("A")); + assertTrue(s.contains("B")); + assertTrue(s.contains("C")); + assertTrue(s.contains("D")); + assertTrue(s.contains("E")); + } + + + /** + * entrySet contains all pairs + */ + public void testDescendingEntrySet() { + ConcurrentNavigableMap map = dmap5(); + Set s = map.entrySet(); + assertEquals(5, s.size()); + Iterator it = s.iterator(); + while (it.hasNext()) { + Map.Entry e = (Map.Entry) it.next(); + assertTrue( + (e.getKey().equals(m1) && e.getValue().equals("A")) || + (e.getKey().equals(m2) && e.getValue().equals("B")) || + (e.getKey().equals(m3) && e.getValue().equals("C")) || + (e.getKey().equals(m4) && e.getValue().equals("D")) || + (e.getKey().equals(m5) && e.getValue().equals("E"))); + } + } + + /** + * putAll adds all key-value pairs from the given map + */ + public void testDescendingPutAll() { + ConcurrentNavigableMap empty = dmap0(); + ConcurrentNavigableMap map = dmap5(); + empty.putAll(map); + assertEquals(5, empty.size()); + assertTrue(empty.containsKey(m1)); + assertTrue(empty.containsKey(m2)); + assertTrue(empty.containsKey(m3)); + assertTrue(empty.containsKey(m4)); + assertTrue(empty.containsKey(m5)); + } + + /** + * putIfAbsent works when the given key is not present + */ + public void testDescendingPutIfAbsent() { + ConcurrentNavigableMap map = dmap5(); + map.putIfAbsent(six, "Z"); + assertTrue(map.containsKey(six)); + } + + /** + * putIfAbsent does not add the pair if the key is already present + */ + public void testDescendingPutIfAbsent2() { + ConcurrentNavigableMap map = dmap5(); + assertEquals("A", map.putIfAbsent(m1, "Z")); + } + + /** + * replace fails when the given key is not present + */ + public void testDescendingReplace() { + ConcurrentNavigableMap map = dmap5(); + assertNull(map.replace(six, "Z")); + assertFalse(map.containsKey(six)); + } + + /** + * replace succeeds if the key is already present + */ + public void testDescendingReplace2() { + ConcurrentNavigableMap map = dmap5(); + assertNotNull(map.replace(m1, "Z")); + assertEquals("Z", map.get(m1)); + } + + + /** + * replace value fails when the given key not mapped to expected value + */ + public void testDescendingReplaceValue() { + ConcurrentNavigableMap map = dmap5(); + assertEquals("A", map.get(m1)); + assertFalse(map.replace(m1, "Z", "Z")); + assertEquals("A", map.get(m1)); + } + + /** + * replace value succeeds when the given key mapped to expected value + */ + public void testDescendingReplaceValue2() { + ConcurrentNavigableMap map = dmap5(); + assertEquals("A", map.get(m1)); + assertTrue(map.replace(m1, "A", "Z")); + assertEquals("Z", map.get(m1)); + } + + + /** + * remove removes the correct key-value pair from the map + */ + public void testDescendingRemove() { + ConcurrentNavigableMap map = dmap5(); + map.remove(m5); + assertEquals(4, map.size()); + assertFalse(map.containsKey(m5)); + } + + /** + * remove(key,value) removes only if pair present + */ + public void testDescendingRemove2() { + ConcurrentNavigableMap map = dmap5(); + assertTrue(map.containsKey(m5)); + assertEquals("E", map.get(m5)); + map.remove(m5, "E"); + assertEquals(4, map.size()); + assertFalse(map.containsKey(m5)); + map.remove(m4, "A"); + assertEquals(4, map.size()); + assertTrue(map.containsKey(m4)); + } + + /** + * lowerEntry returns preceding entry. + */ + public void testDescendingLowerEntry() { + ConcurrentNavigableMap map = dmap5(); + Map.Entry e1 = map.lowerEntry(m3); + assertEquals(m2, e1.getKey()); + + Map.Entry e2 = map.lowerEntry(m6); + assertEquals(m5, e2.getKey()); + + Map.Entry e3 = map.lowerEntry(m1); + assertNull(e3); + + Map.Entry e4 = map.lowerEntry(zero); + assertNull(e4); + } + + /** + * higherEntry returns next entry. + */ + public void testDescendingHigherEntry() { + ConcurrentNavigableMap map = dmap5(); + Map.Entry e1 = map.higherEntry(m3); + assertEquals(m4, e1.getKey()); + + Map.Entry e2 = map.higherEntry(zero); + assertEquals(m1, e2.getKey()); + + Map.Entry e3 = map.higherEntry(m5); + assertNull(e3); + + Map.Entry e4 = map.higherEntry(m6); + assertNull(e4); + } + + /** + * floorEntry returns preceding entry. + */ + public void testDescendingFloorEntry() { + ConcurrentNavigableMap map = dmap5(); + Map.Entry e1 = map.floorEntry(m3); + assertEquals(m3, e1.getKey()); + + Map.Entry e2 = map.floorEntry(m6); + assertEquals(m5, e2.getKey()); + + Map.Entry e3 = map.floorEntry(m1); + assertEquals(m1, e3.getKey()); + + Map.Entry e4 = map.floorEntry(zero); + assertNull(e4); + } + + /** + * ceilingEntry returns next entry. + */ + public void testDescendingCeilingEntry() { + ConcurrentNavigableMap map = dmap5(); + Map.Entry e1 = map.ceilingEntry(m3); + assertEquals(m3, e1.getKey()); + + Map.Entry e2 = map.ceilingEntry(zero); + assertEquals(m1, e2.getKey()); + + Map.Entry e3 = map.ceilingEntry(m5); + assertEquals(m5, e3.getKey()); + + Map.Entry e4 = map.ceilingEntry(m6); + assertNull(e4); + } + + /** + * pollFirstEntry returns entries in order + */ + public void testDescendingPollFirstEntry() { + ConcurrentNavigableMap map = dmap5(); + Map.Entry e = map.pollFirstEntry(); + assertEquals(m1, e.getKey()); + assertEquals("A", e.getValue()); + e = map.pollFirstEntry(); + assertEquals(m2, e.getKey()); + map.put(m1, "A"); + e = map.pollFirstEntry(); + assertEquals(m1, e.getKey()); + assertEquals("A", e.getValue()); + e = map.pollFirstEntry(); + assertEquals(m3, e.getKey()); + map.remove(m4); + e = map.pollFirstEntry(); + assertEquals(m5, e.getKey()); + try { + e.setValue("A"); + shouldThrow(); + } catch (UnsupportedOperationException success) {} + e = map.pollFirstEntry(); + assertNull(e); + } + + /** + * pollLastEntry returns entries in order + */ + public void testDescendingPollLastEntry() { + ConcurrentNavigableMap map = dmap5(); + Map.Entry e = map.pollLastEntry(); + assertEquals(m5, e.getKey()); + assertEquals("E", e.getValue()); + e = map.pollLastEntry(); + assertEquals(m4, e.getKey()); + map.put(m5, "E"); + e = map.pollLastEntry(); + assertEquals(m5, e.getKey()); + assertEquals("E", e.getValue()); + e = map.pollLastEntry(); + assertEquals(m3, e.getKey()); + map.remove(m2); + e = map.pollLastEntry(); + assertEquals(m1, e.getKey()); + try { + e.setValue("E"); + shouldThrow(); + } catch (UnsupportedOperationException success) {} + e = map.pollLastEntry(); + assertNull(e); + } + + /** + * size returns the correct values + */ + public void testDescendingSize() { + ConcurrentNavigableMap map = dmap5(); + ConcurrentNavigableMap empty = dmap0(); + assertEquals(0, empty.size()); + assertEquals(5, map.size()); + } + + /** + * toString contains toString of elements + */ + public void testDescendingToString() { + ConcurrentNavigableMap map = dmap5(); + String s = map.toString(); + for (int i = 1; i <= 5; ++i) { + assertTrue(s.indexOf(String.valueOf(i)) >= 0); + } + } + + // Exception testDescendings + + /** + * get(null) of empty map throws NPE + */ + public void testDescendingGet_NullPointerException() { + try { + ConcurrentNavigableMap c = dmap5(); + c.get(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * containsKey(null) of empty map throws NPE + */ + public void testDescendingContainsKey_NullPointerException() { + try { + ConcurrentNavigableMap c = dmap5(); + c.containsKey(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * containsValue(null) throws NPE + */ + public void testDescendingContainsValue_NullPointerException() { + try { + ConcurrentNavigableMap c = dmap0(); + c.containsValue(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + /** + * put(null,x) throws NPE + */ + public void testDescendingPut1_NullPointerException() { + try { + ConcurrentNavigableMap c = dmap5(); + c.put(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * putIfAbsent(null, x) throws NPE + */ + public void testDescendingPutIfAbsent1_NullPointerException() { + try { + ConcurrentNavigableMap c = dmap5(); + c.putIfAbsent(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * replace(null, x) throws NPE + */ + public void testDescendingReplace_NullPointerException() { + try { + ConcurrentNavigableMap c = dmap5(); + c.replace(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * replace(null, x, y) throws NPE + */ + public void testDescendingReplaceValue_NullPointerException() { + try { + ConcurrentNavigableMap c = dmap5(); + c.replace(null, m1, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * remove(null) throws NPE + */ + public void testDescendingRemove1_NullPointerException() { + try { + ConcurrentNavigableMap c = dmap5(); + c.remove(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * remove(null, x) throws NPE + */ + public void testDescendingRemove2_NullPointerException() { + try { + ConcurrentNavigableMap c = dmap5(); + c.remove(null, "whatever"); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * A deserialized map equals original + */ + public void testDescendingSerialization() throws Exception { + ConcurrentNavigableMap q = dmap5(); + + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + ConcurrentNavigableMap r = (ConcurrentNavigableMap)in.readObject(); + assertEquals(q.size(), r.size()); + assertTrue(q.equals(r)); + assertTrue(r.equals(q)); + } + + + /** + * subMap returns map with keys in requested range + */ + public void testDescendingSubMapContents() { + ConcurrentNavigableMap map = dmap5(); + SortedMap sm = map.subMap(m2, m4); + assertEquals(m2, sm.firstKey()); + assertEquals(m3, sm.lastKey()); + assertEquals(2, sm.size()); + assertFalse(sm.containsKey(m1)); + assertTrue(sm.containsKey(m2)); + assertTrue(sm.containsKey(m3)); + assertFalse(sm.containsKey(m4)); + assertFalse(sm.containsKey(m5)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(m2, k); + k = (Integer)(i.next()); + assertEquals(m3, k); + assertFalse(i.hasNext()); + Iterator j = sm.keySet().iterator(); + j.next(); + j.remove(); + assertFalse(map.containsKey(m2)); + assertEquals(4, map.size()); + assertEquals(1, sm.size()); + assertEquals(m3, sm.firstKey()); + assertEquals(m3, sm.lastKey()); + assertEquals("C", sm.remove(m3)); + assertTrue(sm.isEmpty()); + assertEquals(3, map.size()); + } + + public void testDescendingSubMapContents2() { + ConcurrentNavigableMap map = dmap5(); + SortedMap sm = map.subMap(m2, m3); + assertEquals(1, sm.size()); + assertEquals(m2, sm.firstKey()); + assertEquals(m2, sm.lastKey()); + assertFalse(sm.containsKey(m1)); + assertTrue(sm.containsKey(m2)); + assertFalse(sm.containsKey(m3)); + assertFalse(sm.containsKey(m4)); + assertFalse(sm.containsKey(m5)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(m2, k); + assertFalse(i.hasNext()); + Iterator j = sm.keySet().iterator(); + j.next(); + j.remove(); + assertFalse(map.containsKey(m2)); + assertEquals(4, map.size()); + assertEquals(0, sm.size()); + assertTrue(sm.isEmpty()); + assertSame(sm.remove(m3), null); + assertEquals(4, map.size()); + } + + /** + * headMap returns map with keys in requested range + */ + public void testDescendingHeadMapContents() { + ConcurrentNavigableMap map = dmap5(); + SortedMap sm = map.headMap(m4); + assertTrue(sm.containsKey(m1)); + assertTrue(sm.containsKey(m2)); + assertTrue(sm.containsKey(m3)); + assertFalse(sm.containsKey(m4)); + assertFalse(sm.containsKey(m5)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(m1, k); + k = (Integer)(i.next()); + assertEquals(m2, k); + k = (Integer)(i.next()); + assertEquals(m3, k); + assertFalse(i.hasNext()); + sm.clear(); + assertTrue(sm.isEmpty()); + assertEquals(2, map.size()); + assertEquals(m4, map.firstKey()); + } + + /** + * headMap returns map with keys in requested range + */ + public void testDescendingTailMapContents() { + ConcurrentNavigableMap map = dmap5(); + SortedMap sm = map.tailMap(m2); + assertFalse(sm.containsKey(m1)); + assertTrue(sm.containsKey(m2)); + assertTrue(sm.containsKey(m3)); + assertTrue(sm.containsKey(m4)); + assertTrue(sm.containsKey(m5)); + Iterator i = sm.keySet().iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(m2, k); + k = (Integer)(i.next()); + assertEquals(m3, k); + k = (Integer)(i.next()); + assertEquals(m4, k); + k = (Integer)(i.next()); + assertEquals(m5, k); + assertFalse(i.hasNext()); + + Iterator ei = sm.entrySet().iterator(); + Map.Entry e; + e = (Map.Entry)(ei.next()); + assertEquals(m2, e.getKey()); + assertEquals("B", e.getValue()); + e = (Map.Entry)(ei.next()); + assertEquals(m3, e.getKey()); + assertEquals("C", e.getValue()); + e = (Map.Entry)(ei.next()); + assertEquals(m4, e.getKey()); + assertEquals("D", e.getValue()); + e = (Map.Entry)(ei.next()); + assertEquals(m5, e.getKey()); + assertEquals("E", e.getValue()); + assertFalse(i.hasNext()); + + SortedMap ssm = sm.tailMap(m4); + assertEquals(m4, ssm.firstKey()); + assertEquals(m5, ssm.lastKey()); + assertEquals("D", ssm.remove(m4)); + assertEquals(1, ssm.size()); + assertEquals(3, sm.size()); + assertEquals(4, map.size()); + } + +} diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSubSetTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSubSetTest.java new file mode 100644 index 0000000..9f0a496 --- /dev/null +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSubSetTest.java @@ -0,0 +1,1117 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + */ + +package tests.api.java.util.concurrent; // android-added + +import junit.framework.*; +import java.util.*; +import java.util.concurrent.*; +import java.io.*; + +public class ConcurrentSkipListSubSetTest extends JSR166TestCase { + public static Test suite() { + return new TestSuite(ConcurrentSkipListSubSetTest.class); + } + + static class MyReverseComparator implements Comparator { + public int compare(Object x, Object y) { + return ((Comparable)y).compareTo(x); + } + } + + /** + * Create a set of given size containing consecutive + * Integers 0 ... n. + */ + private NavigableSet populatedSet(int n) { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + assertTrue(q.isEmpty()); + + for (int i = n-1; i >= 0; i-=2) + assertTrue(q.add(new Integer(i))); + for (int i = (n & 1); i < n; i+=2) + assertTrue(q.add(new Integer(i))); + assertTrue(q.add(new Integer(-n))); + assertTrue(q.add(new Integer(n))); + NavigableSet s = q.subSet(new Integer(0), true, new Integer(n), false); + assertFalse(s.isEmpty()); + assertEquals(n, s.size()); + return s; + } + + /** + * Create set of first 5 ints + */ + private NavigableSet set5() { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + assertTrue(q.isEmpty()); + q.add(one); + q.add(two); + q.add(three); + q.add(four); + q.add(five); + q.add(zero); + q.add(seven); + NavigableSet s = q.subSet(one, true, seven, false); + assertEquals(5, s.size()); + return s; + } + + /** + * Create set of first 5 negative ints + */ + private NavigableSet dset5() { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + assertTrue(q.isEmpty()); + q.add(m1); + q.add(m2); + q.add(m3); + q.add(m4); + q.add(m5); + NavigableSet s = q.descendingSet(); + assertEquals(5, s.size()); + return s; + } + + private static NavigableSet set0() { + ConcurrentSkipListSet set = new ConcurrentSkipListSet(); + assertTrue(set.isEmpty()); + return set.tailSet(m1, true); + } + + private static NavigableSet dset0() { + ConcurrentSkipListSet set = new ConcurrentSkipListSet(); + assertTrue(set.isEmpty()); + return set; + } + + /** + * A new set has unbounded capacity + */ + public void testConstructor1() { + assertEquals(0, set0().size()); + } + + + /** + * isEmpty is true before add, false after + */ + public void testEmpty() { + NavigableSet q = set0(); + assertTrue(q.isEmpty()); + q.add(new Integer(1)); + assertFalse(q.isEmpty()); + q.add(new Integer(2)); + q.pollFirst(); + q.pollFirst(); + assertTrue(q.isEmpty()); + } + + /** + * size changes when elements added and removed + */ + public void testSize() { + NavigableSet q = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(SIZE-i, q.size()); + q.pollFirst(); + } + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.size()); + q.add(new Integer(i)); + } + } + + /** + * add(null) throws NPE + */ + public void testAddNull() { + try { + NavigableSet q = set0(); + q.add(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Add of comparable element succeeds + */ + public void testAdd() { + NavigableSet q = set0(); + assertTrue(q.add(six)); + } + + /** + * Add of duplicate element fails + */ + public void testAddDup() { + NavigableSet q = set0(); + assertTrue(q.add(six)); + assertFalse(q.add(six)); + } + + /** + * Add of non-Comparable throws CCE + */ + public void testAddNonComparable() { + try { + NavigableSet q = set0(); + q.add(new Object()); + q.add(new Object()); + q.add(new Object()); + shouldThrow(); + } catch (ClassCastException success) {} + } + + + /** + * addAll(null) throws NPE + */ + public void testAddAll1() { + try { + NavigableSet q = set0(); + q.addAll(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + /** + * addAll of a collection with null elements throws NPE + */ + public void testAddAll2() { + try { + NavigableSet q = set0(); + Integer[] ints = new Integer[SIZE]; + q.addAll(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + /** + * addAll of a collection with any null elements throws NPE after + * possibly adding some elements + */ + public void testAddAll3() { + try { + NavigableSet q = set0(); + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE-1; ++i) + ints[i] = new Integer(i+SIZE); + q.addAll(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Set contains all elements of successful addAll + */ + public void testAddAll5() { + Integer[] empty = new Integer[0]; + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(SIZE-1- i); + NavigableSet q = set0(); + assertFalse(q.addAll(Arrays.asList(empty))); + assertTrue(q.addAll(Arrays.asList(ints))); + for (int i = 0; i < SIZE; ++i) + assertEquals(new Integer(i), q.pollFirst()); + } + + /** + * poll succeeds unless empty + */ + public void testPoll() { + NavigableSet q = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.pollFirst()); + } + assertNull(q.pollFirst()); + } + + /** + * remove(x) removes x and returns true if present + */ + public void testRemoveElement() { + NavigableSet q = populatedSet(SIZE); + for (int i = 1; i < SIZE; i+=2) { + assertTrue(q.remove(new Integer(i))); + } + for (int i = 0; i < SIZE; i+=2) { + assertTrue(q.remove(new Integer(i))); + assertFalse(q.remove(new Integer(i+1))); + } + assertTrue(q.isEmpty()); + } + + /** + * contains(x) reports true when elements added but not yet removed + */ + public void testContains() { + NavigableSet q = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertTrue(q.contains(new Integer(i))); + q.pollFirst(); + assertFalse(q.contains(new Integer(i))); + } + } + + /** + * clear removes all elements + */ + public void testClear() { + NavigableSet q = populatedSet(SIZE); + q.clear(); + assertTrue(q.isEmpty()); + assertEquals(0, q.size()); + q.add(new Integer(1)); + assertFalse(q.isEmpty()); + q.clear(); + assertTrue(q.isEmpty()); + } + + /** + * containsAll(c) is true when c contains a subset of elements + */ + public void testContainsAll() { + NavigableSet q = populatedSet(SIZE); + NavigableSet p = set0(); + for (int i = 0; i < SIZE; ++i) { + assertTrue(q.containsAll(p)); + assertFalse(p.containsAll(q)); + p.add(new Integer(i)); + } + assertTrue(p.containsAll(q)); + } + + /** + * retainAll(c) retains only those elements of c and reports true if changed + */ + public void testRetainAll() { + NavigableSet q = populatedSet(SIZE); + NavigableSet p = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + boolean changed = q.retainAll(p); + if (i == 0) + assertFalse(changed); + else + assertTrue(changed); + + assertTrue(q.containsAll(p)); + assertEquals(SIZE-i, q.size()); + p.pollFirst(); + } + } + + /** + * removeAll(c) removes only those elements of c and reports true if changed + */ + public void testRemoveAll() { + for (int i = 1; i < SIZE; ++i) { + NavigableSet q = populatedSet(SIZE); + NavigableSet p = populatedSet(i); + assertTrue(q.removeAll(p)); + assertEquals(SIZE-i, q.size()); + for (int j = 0; j < i; ++j) { + Integer I = (Integer)(p.pollFirst()); + assertFalse(q.contains(I)); + } + } + } + + + + /** + * lower returns preceding element + */ + public void testLower() { + NavigableSet q = set5(); + Object e1 = q.lower(three); + assertEquals(two, e1); + + Object e2 = q.lower(six); + assertEquals(five, e2); + + Object e3 = q.lower(one); + assertNull(e3); + + Object e4 = q.lower(zero); + assertNull(e4); + } + + /** + * higher returns next element + */ + public void testHigher() { + NavigableSet q = set5(); + Object e1 = q.higher(three); + assertEquals(four, e1); + + Object e2 = q.higher(zero); + assertEquals(one, e2); + + Object e3 = q.higher(five); + assertNull(e3); + + Object e4 = q.higher(six); + assertNull(e4); + } + + /** + * floor returns preceding element + */ + public void testFloor() { + NavigableSet q = set5(); + Object e1 = q.floor(three); + assertEquals(three, e1); + + Object e2 = q.floor(six); + assertEquals(five, e2); + + Object e3 = q.floor(one); + assertEquals(one, e3); + + Object e4 = q.floor(zero); + assertNull(e4); + } + + /** + * ceiling returns next element + */ + public void testCeiling() { + NavigableSet q = set5(); + Object e1 = q.ceiling(three); + assertEquals(three, e1); + + Object e2 = q.ceiling(zero); + assertEquals(one, e2); + + Object e3 = q.ceiling(five); + assertEquals(five, e3); + + Object e4 = q.ceiling(six); + assertNull(e4); + } + + /** + * toArray contains all elements + */ + public void testToArray() { + NavigableSet q = populatedSet(SIZE); + Object[] o = q.toArray(); + Arrays.sort(o); + for (int i = 0; i < o.length; i++) + assertEquals(o[i], q.pollFirst()); + } + + /** + * toArray(a) contains all elements + */ + public void testToArray2() { + NavigableSet q = populatedSet(SIZE); + Integer[] ints = new Integer[SIZE]; + ints = (Integer[])q.toArray(ints); + Arrays.sort(ints); + for (int i = 0; i < ints.length; i++) + assertEquals(ints[i], q.pollFirst()); + } + + /** + * iterator iterates through all elements + */ + public void testIterator() { + NavigableSet q = populatedSet(SIZE); + int i = 0; + Iterator it = q.iterator(); + while (it.hasNext()) { + assertTrue(q.contains(it.next())); + ++i; + } + assertEquals(i, SIZE); + } + + /** + * iterator of empty set has no elements + */ + public void testEmptyIterator() { + NavigableSet q = set0(); + int i = 0; + Iterator it = q.iterator(); + while (it.hasNext()) { + assertTrue(q.contains(it.next())); + ++i; + } + assertEquals(i, 0); + } + + /** + * iterator.remove removes current element + */ + public void testIteratorRemove () { + final NavigableSet q = set0(); + q.add(new Integer(2)); + q.add(new Integer(1)); + q.add(new Integer(3)); + + Iterator it = q.iterator(); + it.next(); + it.remove(); + + it = q.iterator(); + assertEquals(it.next(), new Integer(2)); + assertEquals(it.next(), new Integer(3)); + assertFalse(it.hasNext()); + } + + + /** + * toString contains toStrings of elements + */ + public void testToString() { + NavigableSet q = populatedSet(SIZE); + String s = q.toString(); + for (int i = 0; i < SIZE; ++i) { + assertTrue(s.indexOf(String.valueOf(i)) >= 0); + } + } + + /** + * A deserialized serialized set has same elements + */ + public void testSerialization() throws Exception { + NavigableSet q = populatedSet(SIZE); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + NavigableSet r = (NavigableSet)in.readObject(); + assertEquals(q.size(), r.size()); + while (!q.isEmpty()) + assertEquals(q.pollFirst(), r.pollFirst()); + } + + /** + * subSet returns set with keys in requested range + */ + public void testSubSetContents() { + NavigableSet set = set5(); + SortedSet sm = set.subSet(two, four); + assertEquals(two, sm.first()); + assertEquals(three, sm.last()); + assertEquals(2, sm.size()); + assertFalse(sm.contains(one)); + assertTrue(sm.contains(two)); + assertTrue(sm.contains(three)); + assertFalse(sm.contains(four)); + assertFalse(sm.contains(five)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + assertFalse(i.hasNext()); + Iterator j = sm.iterator(); + j.next(); + j.remove(); + assertFalse(set.contains(two)); + assertEquals(4, set.size()); + assertEquals(1, sm.size()); + assertEquals(three, sm.first()); + assertEquals(three, sm.last()); + assertTrue(sm.remove(three)); + assertTrue(sm.isEmpty()); + assertEquals(3, set.size()); + } + + public void testSubSetContents2() { + NavigableSet set = set5(); + SortedSet sm = set.subSet(two, three); + assertEquals(1, sm.size()); + assertEquals(two, sm.first()); + assertEquals(two, sm.last()); + assertFalse(sm.contains(one)); + assertTrue(sm.contains(two)); + assertFalse(sm.contains(three)); + assertFalse(sm.contains(four)); + assertFalse(sm.contains(five)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + assertFalse(i.hasNext()); + Iterator j = sm.iterator(); + j.next(); + j.remove(); + assertFalse(set.contains(two)); + assertEquals(4, set.size()); + assertEquals(0, sm.size()); + assertTrue(sm.isEmpty()); + assertFalse(sm.remove(three)); + assertEquals(4, set.size()); + } + + /** + * headSet returns set with keys in requested range + */ + public void testHeadSetContents() { + NavigableSet set = set5(); + SortedSet sm = set.headSet(four); + assertTrue(sm.contains(one)); + assertTrue(sm.contains(two)); + assertTrue(sm.contains(three)); + assertFalse(sm.contains(four)); + assertFalse(sm.contains(five)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(one, k); + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + assertFalse(i.hasNext()); + sm.clear(); + assertTrue(sm.isEmpty()); + assertEquals(2, set.size()); + assertEquals(four, set.first()); + } + + /** + * tailSet returns set with keys in requested range + */ + public void testTailSetContents() { + NavigableSet set = set5(); + SortedSet sm = set.tailSet(two); + assertFalse(sm.contains(one)); + assertTrue(sm.contains(two)); + assertTrue(sm.contains(three)); + assertTrue(sm.contains(four)); + assertTrue(sm.contains(five)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(two, k); + k = (Integer)(i.next()); + assertEquals(three, k); + k = (Integer)(i.next()); + assertEquals(four, k); + k = (Integer)(i.next()); + assertEquals(five, k); + assertFalse(i.hasNext()); + + SortedSet ssm = sm.tailSet(four); + assertEquals(four, ssm.first()); + assertEquals(five, ssm.last()); + assertTrue(ssm.remove(four)); + assertEquals(1, ssm.size()); + assertEquals(3, sm.size()); + assertEquals(4, set.size()); + } + + /** + * size changes when elements added and removed + */ + public void testDescendingSize() { + NavigableSet q = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(SIZE-i, q.size()); + q.pollFirst(); + } + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.size()); + q.add(new Integer(i)); + } + } + + /** + * add(null) throws NPE + */ + public void testDescendingAddNull() { + try { + NavigableSet q = dset0(); + q.add(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Add of comparable element succeeds + */ + public void testDescendingAdd() { + NavigableSet q = dset0(); + assertTrue(q.add(m6)); + } + + /** + * Add of duplicate element fails + */ + public void testDescendingAddDup() { + NavigableSet q = dset0(); + assertTrue(q.add(m6)); + assertFalse(q.add(m6)); + } + + /** + * Add of non-Comparable throws CCE + */ + public void testDescendingAddNonComparable() { + try { + NavigableSet q = dset0(); + q.add(new Object()); + q.add(new Object()); + q.add(new Object()); + shouldThrow(); + } catch (ClassCastException success) {} + } + + + /** + * addAll(null) throws NPE + */ + public void testDescendingAddAll1() { + try { + NavigableSet q = dset0(); + q.addAll(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + /** + * addAll of a collection with null elements throws NPE + */ + public void testDescendingAddAll2() { + try { + NavigableSet q = dset0(); + Integer[] ints = new Integer[SIZE]; + q.addAll(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + /** + * addAll of a collection with any null elements throws NPE after + * possibly adding some elements + */ + public void testDescendingAddAll3() { + try { + NavigableSet q = dset0(); + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE-1; ++i) + ints[i] = new Integer(i+SIZE); + q.addAll(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Set contains all elements of successful addAll + */ + public void testDescendingAddAll5() { + Integer[] empty = new Integer[0]; + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(SIZE-1- i); + NavigableSet q = dset0(); + assertFalse(q.addAll(Arrays.asList(empty))); + assertTrue(q.addAll(Arrays.asList(ints))); + for (int i = 0; i < SIZE; ++i) + assertEquals(new Integer(i), q.pollFirst()); + } + + /** + * poll succeeds unless empty + */ + public void testDescendingPoll() { + NavigableSet q = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.pollFirst()); + } + assertNull(q.pollFirst()); + } + + /** + * remove(x) removes x and returns true if present + */ + public void testDescendingRemoveElement() { + NavigableSet q = populatedSet(SIZE); + for (int i = 1; i < SIZE; i+=2) { + assertTrue(q.remove(new Integer(i))); + } + for (int i = 0; i < SIZE; i+=2) { + assertTrue(q.remove(new Integer(i))); + assertFalse(q.remove(new Integer(i+1))); + } + assertTrue(q.isEmpty()); + } + + /** + * contains(x) reports true when elements added but not yet removed + */ + public void testDescendingContains() { + NavigableSet q = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertTrue(q.contains(new Integer(i))); + q.pollFirst(); + assertFalse(q.contains(new Integer(i))); + } + } + + /** + * clear removes all elements + */ + public void testDescendingClear() { + NavigableSet q = populatedSet(SIZE); + q.clear(); + assertTrue(q.isEmpty()); + assertEquals(0, q.size()); + q.add(new Integer(1)); + assertFalse(q.isEmpty()); + q.clear(); + assertTrue(q.isEmpty()); + } + + /** + * containsAll(c) is true when c contains a subset of elements + */ + public void testDescendingContainsAll() { + NavigableSet q = populatedSet(SIZE); + NavigableSet p = dset0(); + for (int i = 0; i < SIZE; ++i) { + assertTrue(q.containsAll(p)); + assertFalse(p.containsAll(q)); + p.add(new Integer(i)); + } + assertTrue(p.containsAll(q)); + } + + /** + * retainAll(c) retains only those elements of c and reports true if changed + */ + public void testDescendingRetainAll() { + NavigableSet q = populatedSet(SIZE); + NavigableSet p = populatedSet(SIZE); + for (int i = 0; i < SIZE; ++i) { + boolean changed = q.retainAll(p); + if (i == 0) + assertFalse(changed); + else + assertTrue(changed); + + assertTrue(q.containsAll(p)); + assertEquals(SIZE-i, q.size()); + p.pollFirst(); + } + } + + /** + * removeAll(c) removes only those elements of c and reports true if changed + */ + public void testDescendingRemoveAll() { + for (int i = 1; i < SIZE; ++i) { + NavigableSet q = populatedSet(SIZE); + NavigableSet p = populatedSet(i); + assertTrue(q.removeAll(p)); + assertEquals(SIZE-i, q.size()); + for (int j = 0; j < i; ++j) { + Integer I = (Integer)(p.pollFirst()); + assertFalse(q.contains(I)); + } + } + } + + + + /** + * lower returns preceding element + */ + public void testDescendingLower() { + NavigableSet q = dset5(); + Object e1 = q.lower(m3); + assertEquals(m2, e1); + + Object e2 = q.lower(m6); + assertEquals(m5, e2); + + Object e3 = q.lower(m1); + assertNull(e3); + + Object e4 = q.lower(zero); + assertNull(e4); + } + + /** + * higher returns next element + */ + public void testDescendingHigher() { + NavigableSet q = dset5(); + Object e1 = q.higher(m3); + assertEquals(m4, e1); + + Object e2 = q.higher(zero); + assertEquals(m1, e2); + + Object e3 = q.higher(m5); + assertNull(e3); + + Object e4 = q.higher(m6); + assertNull(e4); + } + + /** + * floor returns preceding element + */ + public void testDescendingFloor() { + NavigableSet q = dset5(); + Object e1 = q.floor(m3); + assertEquals(m3, e1); + + Object e2 = q.floor(m6); + assertEquals(m5, e2); + + Object e3 = q.floor(m1); + assertEquals(m1, e3); + + Object e4 = q.floor(zero); + assertNull(e4); + } + + /** + * ceiling returns next element + */ + public void testDescendingCeiling() { + NavigableSet q = dset5(); + Object e1 = q.ceiling(m3); + assertEquals(m3, e1); + + Object e2 = q.ceiling(zero); + assertEquals(m1, e2); + + Object e3 = q.ceiling(m5); + assertEquals(m5, e3); + + Object e4 = q.ceiling(m6); + assertNull(e4); + } + + /** + * toArray contains all elements + */ + public void testDescendingToArray() { + NavigableSet q = populatedSet(SIZE); + Object[] o = q.toArray(); + Arrays.sort(o); + for (int i = 0; i < o.length; i++) + assertEquals(o[i], q.pollFirst()); + } + + /** + * toArray(a) contains all elements + */ + public void testDescendingToArray2() { + NavigableSet q = populatedSet(SIZE); + Integer[] ints = new Integer[SIZE]; + ints = (Integer[])q.toArray(ints); + Arrays.sort(ints); + for (int i = 0; i < ints.length; i++) + assertEquals(ints[i], q.pollFirst()); + } + + /** + * iterator iterates through all elements + */ + public void testDescendingIterator() { + NavigableSet q = populatedSet(SIZE); + int i = 0; + Iterator it = q.iterator(); + while (it.hasNext()) { + assertTrue(q.contains(it.next())); + ++i; + } + assertEquals(i, SIZE); + } + + /** + * iterator of empty set has no elements + */ + public void testDescendingEmptyIterator() { + NavigableSet q = dset0(); + int i = 0; + Iterator it = q.iterator(); + while (it.hasNext()) { + assertTrue(q.contains(it.next())); + ++i; + } + assertEquals(i, 0); + } + + /** + * iterator.remove removes current element + */ + public void testDescendingIteratorRemove () { + final NavigableSet q = dset0(); + q.add(new Integer(2)); + q.add(new Integer(1)); + q.add(new Integer(3)); + + Iterator it = q.iterator(); + it.next(); + it.remove(); + + it = q.iterator(); + assertEquals(it.next(), new Integer(2)); + assertEquals(it.next(), new Integer(3)); + assertFalse(it.hasNext()); + } + + + /** + * toString contains toStrings of elements + */ + public void testDescendingToString() { + NavigableSet q = populatedSet(SIZE); + String s = q.toString(); + for (int i = 0; i < SIZE; ++i) { + assertTrue(s.indexOf(String.valueOf(i)) >= 0); + } + } + + /** + * A deserialized serialized set has same elements + */ + public void testDescendingSerialization() throws Exception { + NavigableSet q = populatedSet(SIZE); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + NavigableSet r = (NavigableSet)in.readObject(); + assertEquals(q.size(), r.size()); + while (!q.isEmpty()) + assertEquals(q.pollFirst(), r.pollFirst()); + } + + /** + * subSet returns set with keys in requested range + */ + public void testDescendingSubSetContents() { + NavigableSet set = dset5(); + SortedSet sm = set.subSet(m2, m4); + assertEquals(m2, sm.first()); + assertEquals(m3, sm.last()); + assertEquals(2, sm.size()); + assertFalse(sm.contains(m1)); + assertTrue(sm.contains(m2)); + assertTrue(sm.contains(m3)); + assertFalse(sm.contains(m4)); + assertFalse(sm.contains(m5)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(m2, k); + k = (Integer)(i.next()); + assertEquals(m3, k); + assertFalse(i.hasNext()); + Iterator j = sm.iterator(); + j.next(); + j.remove(); + assertFalse(set.contains(m2)); + assertEquals(4, set.size()); + assertEquals(1, sm.size()); + assertEquals(m3, sm.first()); + assertEquals(m3, sm.last()); + assertTrue(sm.remove(m3)); + assertTrue(sm.isEmpty()); + assertEquals(3, set.size()); + } + + public void testDescendingSubSetContents2() { + NavigableSet set = dset5(); + SortedSet sm = set.subSet(m2, m3); + assertEquals(1, sm.size()); + assertEquals(m2, sm.first()); + assertEquals(m2, sm.last()); + assertFalse(sm.contains(m1)); + assertTrue(sm.contains(m2)); + assertFalse(sm.contains(m3)); + assertFalse(sm.contains(m4)); + assertFalse(sm.contains(m5)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(m2, k); + assertFalse(i.hasNext()); + Iterator j = sm.iterator(); + j.next(); + j.remove(); + assertFalse(set.contains(m2)); + assertEquals(4, set.size()); + assertEquals(0, sm.size()); + assertTrue(sm.isEmpty()); + assertFalse(sm.remove(m3)); + assertEquals(4, set.size()); + } + + /** + * headSet returns set with keys in requested range + */ + public void testDescendingHeadSetContents() { + NavigableSet set = dset5(); + SortedSet sm = set.headSet(m4); + assertTrue(sm.contains(m1)); + assertTrue(sm.contains(m2)); + assertTrue(sm.contains(m3)); + assertFalse(sm.contains(m4)); + assertFalse(sm.contains(m5)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(m1, k); + k = (Integer)(i.next()); + assertEquals(m2, k); + k = (Integer)(i.next()); + assertEquals(m3, k); + assertFalse(i.hasNext()); + sm.clear(); + assertTrue(sm.isEmpty()); + assertEquals(2, set.size()); + assertEquals(m4, set.first()); + } + + /** + * tailSet returns set with keys in requested range + */ + public void testDescendingTailSetContents() { + NavigableSet set = dset5(); + SortedSet sm = set.tailSet(m2); + assertFalse(sm.contains(m1)); + assertTrue(sm.contains(m2)); + assertTrue(sm.contains(m3)); + assertTrue(sm.contains(m4)); + assertTrue(sm.contains(m5)); + Iterator i = sm.iterator(); + Object k; + k = (Integer)(i.next()); + assertEquals(m2, k); + k = (Integer)(i.next()); + assertEquals(m3, k); + k = (Integer)(i.next()); + assertEquals(m4, k); + k = (Integer)(i.next()); + assertEquals(m5, k); + assertFalse(i.hasNext()); + + SortedSet ssm = sm.tailSet(m4); + assertEquals(m4, ssm.first()); + assertEquals(m5, ssm.last()); + assertTrue(ssm.remove(m4)); + assertEquals(1, ssm.size()); + assertEquals(3, sm.size()); + assertEquals(4, set.size()); + } + +} diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/CopyOnWriteArrayListTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/CopyOnWriteArrayListTest.java index 53a1f70..90d708a 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/CopyOnWriteArrayListTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/CopyOnWriteArrayListTest.java @@ -2,26 +2,26 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; import java.io.*; -public class CopyOnWriteArrayListTest extends JSR166TestCase{ +public class CopyOnWriteArrayListTest extends JSR166TestCase { public static Test suite() { return new TestSuite(CopyOnWriteArrayListTest.class); } - static CopyOnWriteArrayList populatedArray(int n){ + static CopyOnWriteArrayList populatedArray(int n) { CopyOnWriteArrayList a = new CopyOnWriteArrayList(); assertTrue(a.isEmpty()); - for (int i = 0; i < n; ++i) + for (int i = 0; i < n; ++i) a.add(new Integer(i)); assertFalse(a.isEmpty()); assertEquals(n, a.size()); @@ -45,7 +45,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ for (int i = 0; i < SIZE-1; ++i) ints[i] = new Integer(i); CopyOnWriteArrayList a = new CopyOnWriteArrayList(ints); - for (int i = 0; i < SIZE; ++i) + for (int i = 0; i < SIZE; ++i) assertEquals(ints[i], a.get(i)); } @@ -57,10 +57,10 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ for (int i = 0; i < SIZE-1; ++i) ints[i] = new Integer(i); CopyOnWriteArrayList a = new CopyOnWriteArrayList(Arrays.asList(ints)); - for (int i = 0; i < SIZE; ++i) + for (int i = 0; i < SIZE; ++i) assertEquals(ints[i], a.get(i)); } - + /** * addAll adds each element from the given collection @@ -171,7 +171,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ assertEquals(a.hashCode(), b.hashCode()); } - + /** * containsAll returns true for collection with subset of elements */ @@ -186,11 +186,11 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ } /** - * get returns the value at the given index + * get returns the value at the given index */ public void testGet() { CopyOnWriteArrayList full = populatedArray(3); - assertEquals(0, ((Integer)full.get(0)).intValue()); + assertEquals(0, full.get(0)); } /** @@ -223,14 +223,14 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ } /** - * iterator() returns an iterator containing the elements of the list + * iterator() returns an iterator containing the elements of the list */ public void testIterator() { CopyOnWriteArrayList full = populatedArray(SIZE); Iterator i = full.iterator(); int j; - for(j = 0; i.hasNext(); j++) - assertEquals(j, ((Integer)i.next()).intValue()); + for (j = 0; i.hasNext(); j++) + assertEquals(j, i.next()); assertEquals(SIZE, j); } @@ -244,8 +244,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ try { it.remove(); shouldThrow(); - } - catch (UnsupportedOperationException success) {} + } catch (UnsupportedOperationException success) {} } /** @@ -257,7 +256,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ for (int i = 0; i < 3; ++i) { assertTrue(s.indexOf(String.valueOf(i)) >= 0); } - } + } /** * lastIndexOf returns the index for the given object @@ -288,8 +287,8 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ CopyOnWriteArrayList full = populatedArray(SIZE); ListIterator i = full.listIterator(); int j; - for(j = 0; i.hasNext(); j++) - assertEquals(j, ((Integer)i.next()).intValue()); + for (j = 0; i.hasNext(); j++) + assertEquals(j, i.next()); assertEquals(SIZE, j); } @@ -300,8 +299,8 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ CopyOnWriteArrayList full = populatedArray(3); ListIterator i = full.listIterator(1); int j; - for(j = 0; i.hasNext(); j++) - assertEquals(j+1, ((Integer)i.next()).intValue()); + for (j = 0; i.hasNext(); j++) + assertEquals(j+1, i.next()); assertEquals(2, j); } @@ -310,7 +309,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ */ public void testRemove() { CopyOnWriteArrayList full = populatedArray(3); - assertEquals(two, full.remove(2)); + assertEquals(2, full.remove(2)); assertEquals(2, full.size()); } @@ -331,8 +330,8 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ */ public void testSet() { CopyOnWriteArrayList full = populatedArray(3); - assertEquals(two, full.set(2, four)); - assertEquals(4, ((Integer)full.get(2)).intValue()); + assertEquals(2, full.set(2, four)); + assertEquals(4, full.get(2)); } /** @@ -352,9 +351,9 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ CopyOnWriteArrayList full = populatedArray(3); Object[] o = full.toArray(); assertEquals(3, o.length); - assertEquals(0, ((Integer)o[0]).intValue()); - assertEquals(1, ((Integer)o[1]).intValue()); - assertEquals(2, ((Integer)o[2]).intValue()); + assertEquals(0, o[0]); + assertEquals(1, o[1]); + assertEquals(2, o[2]); } /** @@ -378,10 +377,10 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ public void testSubList() { CopyOnWriteArrayList a = populatedArray(10); assertTrue(a.subList(1,1).isEmpty()); - for(int j = 0; j < 9; ++j) { - for(int i = j ; i < 10; ++i) { + for (int j = 0; j < 9; ++j) { + for (int i = j ; i < 10; ++i) { List b = a.subList(j,i); - for(int k = j; k < i; ++k) { + for (int k = j; k < i; ++k) { assertEquals(new Integer(k), b.get(k-j)); } } @@ -408,7 +407,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ c.add("asdadasd"); c.toArray(new Long[5]); shouldThrow(); - } catch(ArrayStoreException e){} + } catch (ArrayStoreException success) {} } /** @@ -419,9 +418,9 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ CopyOnWriteArrayList c = new CopyOnWriteArrayList(); c.get(-1); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } - + /** * get throws an IndexOutOfBoundsException on a too high index */ @@ -432,7 +431,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ c.add("asdad"); c.get(100); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } /** @@ -443,9 +442,9 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ CopyOnWriteArrayList c = new CopyOnWriteArrayList(); c.set(-1,"qwerty"); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } - + /** * set throws an IndexOutOfBoundsException on a too high index */ @@ -456,7 +455,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ c.add("asdad"); c.set(100, "qwerty"); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } /** @@ -467,9 +466,9 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ CopyOnWriteArrayList c = new CopyOnWriteArrayList(); c.add(-1,"qwerty"); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } - + /** * add throws an IndexOutOfBoundsException on a too high index */ @@ -480,7 +479,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ c.add("asdasdasd"); c.add(100, "qwerty"); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } /** @@ -491,7 +490,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ CopyOnWriteArrayList c = new CopyOnWriteArrayList(); c.remove(-1); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } /** @@ -504,9 +503,9 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ c.add("adasdasd"); c.remove(100); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } - + /** * addAll throws an IndexOutOfBoundsException on a negative index */ @@ -515,9 +514,9 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ CopyOnWriteArrayList c = new CopyOnWriteArrayList(); c.addAll(-1,new LinkedList()); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } - + /** * addAll throws an IndexOutOfBoundsException on a too high index */ @@ -528,7 +527,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ c.add("asdasdasd"); c.addAll(100, new LinkedList()); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } /** @@ -539,7 +538,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ CopyOnWriteArrayList c = new CopyOnWriteArrayList(); c.listIterator(-1); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } /** @@ -552,7 +551,7 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ c.add("asdasdas"); c.listIterator(100); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } /** @@ -562,9 +561,8 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ try { CopyOnWriteArrayList c = new CopyOnWriteArrayList(); c.subList(-1,100); - shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } /** @@ -576,43 +574,38 @@ public class CopyOnWriteArrayListTest extends JSR166TestCase{ c.add("asdasd"); c.subList(1,100); shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } /** * subList throws IndexOutOfBoundsException when the second index - * is lower then the first + * is lower then the first */ public void testSubList3_IndexOutOfBoundsException() { try { CopyOnWriteArrayList c = new CopyOnWriteArrayList(); c.subList(3,1); - shouldThrow(); - } catch(IndexOutOfBoundsException e){} + } catch (IndexOutOfBoundsException success) {} } /** - * a deserialized serialiszed list is equal + * a deserialized serialized list is equal */ - public void testSerialization() { + public void testSerialization() throws Exception { CopyOnWriteArrayList q = populatedArray(SIZE); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(q); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - CopyOnWriteArrayList r = (CopyOnWriteArrayList)in.readObject(); - assertEquals(q.size(), r.size()); - assertTrue(q.equals(r)); - assertTrue(r.equals(q)); - } catch(Exception e){ - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + CopyOnWriteArrayList r = (CopyOnWriteArrayList)in.readObject(); + assertEquals(q.size(), r.size()); + assertTrue(q.equals(r)); + assertTrue(r.equals(q)); } - + } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/CopyOnWriteArraySetTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/CopyOnWriteArraySetTest.java index abb33fa..c78ac50 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/CopyOnWriteArraySetTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/CopyOnWriteArraySetTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; @@ -18,10 +18,10 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { return new TestSuite(CopyOnWriteArraySetTest.class); } - static CopyOnWriteArraySet populatedSet(int n){ + static CopyOnWriteArraySet populatedSet(int n) { CopyOnWriteArraySet a = new CopyOnWriteArraySet(); assertTrue(a.isEmpty()); - for (int i = 0; i < n; ++i) + for (int i = 0; i < n; ++i) a.add(new Integer(i)); assertFalse(a.isEmpty()); assertEquals(n, a.size()); @@ -44,13 +44,13 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { for (int i = 0; i < SIZE-1; ++i) ints[i] = new Integer(i); CopyOnWriteArraySet a = new CopyOnWriteArraySet(Arrays.asList(ints)); - for (int i = 0; i < SIZE; ++i) + for (int i = 0; i < SIZE; ++i) assertTrue(a.contains(ints[i])); } - + /** - * addAll adds each element from the given collection + * addAll adds each element from the given collection */ public void testAddAll() { CopyOnWriteArraySet full = populatedSet(3); @@ -63,7 +63,7 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { } /** - * addAll adds each element from the given collection that did not + * addAll adds each element from the given collection that did not * already exist in the set */ public void testAddAll2() { @@ -77,7 +77,7 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { } /** - * add will not add the element if it already exists in the set + * add will not add the element if it already exists in the set */ public void testAdd2() { CopyOnWriteArraySet full = populatedSet(3); @@ -86,8 +86,8 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { } /** - * add adds the element when it does not exist - * in the set + * add adds the element when it does not exist + * in the set */ public void testAdd3() { CopyOnWriteArraySet full = populatedSet(3); @@ -96,7 +96,7 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { } /** - * clear removes all elements from the set + * clear removes all elements from the set */ public void testClear() { CopyOnWriteArraySet full = populatedSet(3); @@ -131,9 +131,9 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { assertEquals(a.hashCode(), b.hashCode()); } - + /** - * containsAll returns true for collections with subset of elements + * containsAll returns true for collections with subset of elements */ public void testContainsAll() { CopyOnWriteArraySet full = populatedSet(3); @@ -146,7 +146,7 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { } /** - * isEmpty is true when empty, else false + * isEmpty is true when empty, else false */ public void testIsEmpty() { CopyOnWriteArraySet empty = new CopyOnWriteArraySet(); @@ -156,14 +156,14 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { } /** - * iterator() returns an iterator containing the elements of the set + * iterator() returns an iterator containing the elements of the set */ public void testIterator() { CopyOnWriteArraySet full = populatedSet(3); Iterator i = full.iterator(); int j; - for(j = 0; i.hasNext(); j++) - assertEquals(j, ((Integer)i.next()).intValue()); + for (j = 0; i.hasNext(); j++) + assertEquals(j, i.next()); assertEquals(3, j); } @@ -177,8 +177,7 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { try { it.remove(); shouldThrow(); - } - catch (UnsupportedOperationException success) {} + } catch (UnsupportedOperationException success) {} } /** @@ -190,11 +189,11 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { for (int i = 0; i < 3; ++i) { assertTrue(s.indexOf(String.valueOf(i)) >= 0); } - } + } /** - * removeAll removes all elements from the given collection + * removeAll removes all elements from the given collection */ public void testRemoveAll() { CopyOnWriteArraySet full = populatedSet(3); @@ -217,7 +216,7 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { } /** - * size returns the number of elements + * size returns the number of elements */ public void testSize() { CopyOnWriteArraySet empty = new CopyOnWriteArraySet(); @@ -227,29 +226,29 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { } /** - * toArray returns an Object array containing all elements from the set + * toArray returns an Object array containing all elements from the set */ public void testToArray() { CopyOnWriteArraySet full = populatedSet(3); Object[] o = full.toArray(); assertEquals(3, o.length); - assertEquals(0, ((Integer)o[0]).intValue()); - assertEquals(1, ((Integer)o[1]).intValue()); - assertEquals(2, ((Integer)o[2]).intValue()); + assertEquals(0, o[0]); + assertEquals(1, o[1]); + assertEquals(2, o[2]); } /** - * toArray returns an Integer array containing all elements from - * the set + * toArray returns an Integer array containing all elements from + * the set */ public void testToArray2() { CopyOnWriteArraySet full = populatedSet(3); Integer[] i = new Integer[3]; i = (Integer[])full.toArray(i); assertEquals(3, i.length); - assertEquals(0, i[0].intValue()); - assertEquals(1, i[1].intValue()); - assertEquals(2, i[2].intValue()); + assertEquals(0, (int) i[0]); + assertEquals(1, (int) i[1]); + assertEquals(2, (int) i[2]); } @@ -264,30 +263,26 @@ public class CopyOnWriteArraySetTest extends JSR166TestCase { c.add("asdadasd"); c.toArray(new Long[5]); shouldThrow(); - } catch(ArrayStoreException e){} + } catch (ArrayStoreException success) {} } /** * A deserialized serialized set is equal */ - public void testSerialization() { + public void testSerialization() throws Exception { CopyOnWriteArraySet q = populatedSet(SIZE); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(q); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - CopyOnWriteArraySet r = (CopyOnWriteArraySet)in.readObject(); - assertEquals(q.size(), r.size()); - assertTrue(q.equals(r)); - assertTrue(r.equals(q)); - } catch(Exception e){ - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + CopyOnWriteArraySet r = (CopyOnWriteArraySet)in.readObject(); + assertEquals(q.size(), r.size()); + assertTrue(q.equals(r)); + assertTrue(r.equals(q)); } } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/CountDownLatchTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/CountDownLatchTest.java index 179c81e..b06004e 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/CountDownLatchTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/CountDownLatchTest.java @@ -2,15 +2,16 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; public class CountDownLatchTest extends JSR166TestCase { public static Test suite() { @@ -24,7 +25,7 @@ public class CountDownLatchTest extends JSR166TestCase { try { new CountDownLatch(-1); shouldThrow(); - } catch(IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } /** @@ -52,137 +53,99 @@ public class CountDownLatchTest extends JSR166TestCase { /** * await returns after countDown to zero, but not before */ - public void testAwait() { + public void testAwait() throws InterruptedException { final CountDownLatch l = new CountDownLatch(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertTrue(l.getCount() > 0); - l.await(); - threadAssertTrue(l.getCount() == 0); - } catch(InterruptedException e){ - threadUnexpectedException(); - } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + threadAssertTrue(l.getCount() > 0); + l.await(); + threadAssertTrue(l.getCount() == 0); + }}); + t.start(); - try { - assertEquals(l.getCount(), 2); - Thread.sleep(SHORT_DELAY_MS); - l.countDown(); - assertEquals(l.getCount(), 1); - l.countDown(); - assertEquals(l.getCount(), 0); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + assertEquals(l.getCount(), 2); + Thread.sleep(SHORT_DELAY_MS); + l.countDown(); + assertEquals(l.getCount(), 1); + l.countDown(); + assertEquals(l.getCount(), 0); + t.join(); } - + /** * timed await returns after countDown to zero */ - public void testTimedAwait() { + public void testTimedAwait() throws InterruptedException { final CountDownLatch l = new CountDownLatch(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertTrue(l.getCount() > 0); - threadAssertTrue(l.await(SMALL_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch(InterruptedException e){ - threadUnexpectedException(); - } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + threadAssertTrue(l.getCount() > 0); + threadAssertTrue(l.await(SMALL_DELAY_MS, MILLISECONDS)); + }}); + t.start(); - try { - assertEquals(l.getCount(), 2); - Thread.sleep(SHORT_DELAY_MS); - l.countDown(); - assertEquals(l.getCount(), 1); - l.countDown(); - assertEquals(l.getCount(), 0); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + assertEquals(l.getCount(), 2); + Thread.sleep(SHORT_DELAY_MS); + l.countDown(); + assertEquals(l.getCount(), 1); + l.countDown(); + assertEquals(l.getCount(), 0); + t.join(); } - + /** * await throws IE if interrupted before counted down */ - public void testAwait_InterruptedException() { + public void testAwait_InterruptedException() throws InterruptedException { final CountDownLatch l = new CountDownLatch(1); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertTrue(l.getCount() > 0); - l.await(); - threadShouldThrow(); - } catch(InterruptedException success){} - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + threadAssertTrue(l.getCount() > 0); + l.await(); + }}); + t.start(); - try { - assertEquals(l.getCount(), 1); - t.interrupt(); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + assertEquals(l.getCount(), 1); + t.interrupt(); + t.join(); } /** * timed await throws IE if interrupted before counted down */ - public void testTimedAwait_InterruptedException() { + public void testTimedAwait_InterruptedException() throws InterruptedException { final CountDownLatch l = new CountDownLatch(1); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertTrue(l.getCount() > 0); - l.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(InterruptedException success){} - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + threadAssertTrue(l.getCount() > 0); + l.await(MEDIUM_DELAY_MS, MILLISECONDS); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - assertEquals(l.getCount(), 1); - t.interrupt(); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + assertEquals(l.getCount(), 1); + t.interrupt(); + t.join(); } /** * timed await times out if not counted down before timeout */ - public void testAwaitTimeout() { + public void testAwaitTimeout() throws InterruptedException { final CountDownLatch l = new CountDownLatch(1); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertTrue(l.getCount() > 0); - threadAssertFalse(l.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(l.getCount() > 0); - } catch(InterruptedException ie){ - threadUnexpectedException(); - } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + threadAssertTrue(l.getCount() > 0); + threadAssertFalse(l.await(SHORT_DELAY_MS, MILLISECONDS)); + threadAssertTrue(l.getCount() > 0); + }}); + t.start(); - try { - assertEquals(l.getCount(), 1); - t.join(); - } catch (InterruptedException e){ - unexpectedException(); - } + assertEquals(l.getCount(), 1); + t.join(); } /** diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/CyclicBarrierTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/CyclicBarrierTest.java index 3b99ef8..b8f8b24 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/CyclicBarrierTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/CyclicBarrierTest.java @@ -2,19 +2,20 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; import java.util.concurrent.locks.*; import java.util.concurrent.atomic.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; -public class CyclicBarrierTest extends JSR166TestCase{ +public class CyclicBarrierTest extends JSR166TestCase { public static Test suite() { return new TestSuite(CyclicBarrierTest.class); } @@ -23,7 +24,7 @@ public class CyclicBarrierTest extends JSR166TestCase{ private class MyAction implements Runnable { public void run() { ++countAction; } } - + /** * Creating with negative parties throws IAE */ @@ -31,7 +32,7 @@ public class CyclicBarrierTest extends JSR166TestCase{ try { new CyclicBarrier(-1, (Runnable)null); shouldThrow(); - } catch(IllegalArgumentException e){} + } catch (IllegalArgumentException success) {} } /** @@ -41,7 +42,7 @@ public class CyclicBarrierTest extends JSR166TestCase{ try { new CyclicBarrier(-1); shouldThrow(); - } catch(IllegalArgumentException e){} + } catch (IllegalArgumentException success) {} } /** @@ -56,65 +57,48 @@ public class CyclicBarrierTest extends JSR166TestCase{ /** * A 1-party barrier triggers after single await */ - public void testSingleParty() { - try { - CyclicBarrier b = new CyclicBarrier(1); - assertEquals(1, b.getParties()); - assertEquals(0, b.getNumberWaiting()); - b.await(); - b.await(); - assertEquals(0, b.getNumberWaiting()); - } - catch(Exception e) { - unexpectedException(); - } + public void testSingleParty() throws Exception { + CyclicBarrier b = new CyclicBarrier(1); + assertEquals(1, b.getParties()); + assertEquals(0, b.getNumberWaiting()); + b.await(); + b.await(); + assertEquals(0, b.getNumberWaiting()); } - + /** * The supplied barrier action is run at barrier */ - public void testBarrierAction() { - try { - countAction = 0; - CyclicBarrier b = new CyclicBarrier(1, new MyAction()); - assertEquals(1, b.getParties()); - assertEquals(0, b.getNumberWaiting()); - b.await(); - b.await(); - assertEquals(0, b.getNumberWaiting()); - assertEquals(countAction, 2); - } - catch(Exception e) { - unexpectedException(); - } + public void testBarrierAction() throws Exception { + countAction = 0; + CyclicBarrier b = new CyclicBarrier(1, new MyAction()); + assertEquals(1, b.getParties()); + assertEquals(0, b.getNumberWaiting()); + b.await(); + b.await(); + assertEquals(0, b.getNumberWaiting()); + assertEquals(countAction, 2); } /** * A 2-party/thread barrier triggers after both threads invoke await */ - public void testTwoParties() { + public void testTwoParties() throws Exception { final CyclicBarrier b = new CyclicBarrier(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - b.await(); - b.await(); - b.await(); - b.await(); - } catch(Exception e){ - threadUnexpectedException(); - }}}); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws Exception { + b.await(); + b.await(); + b.await(); + b.await(); + }}); - try { - t.start(); - b.await(); - b.await(); - b.await(); - b.await(); - t.join(); - } catch(Exception e){ - unexpectedException(); - } + t.start(); + b.await(); + b.await(); + b.await(); + b.await(); + t.join(); } @@ -122,502 +106,320 @@ public class CyclicBarrierTest extends JSR166TestCase{ * An interruption in one party causes others waiting in await to * throw BrokenBarrierException */ - public void testAwait1_Interrupted_BrokenBarrier() { + public void testAwait1_Interrupted_BrokenBarrier() throws Exception { final CyclicBarrier c = new CyclicBarrier(3); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - c.await(); - threadShouldThrow(); - } catch(InterruptedException success){} - catch(Exception b){ - threadUnexpectedException(); - } - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - c.await(); - threadShouldThrow(); - } catch(BrokenBarrierException success){ - } catch(Exception i){ - threadUnexpectedException(); - } - } - }); - try { - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - t1.interrupt(); - t1.join(); - t2.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread t1 = new ThreadShouldThrow(InterruptedException.class) { + public void realRun() throws Exception { + c.await(); + }}; + Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) { + public void realRun() throws Exception { + c.await(); + }}; + + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + t1.interrupt(); + t1.join(); + t2.join(); } /** * An interruption in one party causes others waiting in timed await to * throw BrokenBarrierException */ - public void testAwait2_Interrupted_BrokenBarrier() { + public void testAwait2_Interrupted_BrokenBarrier() throws Exception { final CyclicBarrier c = new CyclicBarrier(3); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - c.await(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(InterruptedException success){ - } catch(Exception b){ - threadUnexpectedException(); - } - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - c.await(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(BrokenBarrierException success){ - } catch(Exception i){ - threadUnexpectedException(); - } - } - }); - try { - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - t1.interrupt(); - t1.join(); - t2.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread t1 = new ThreadShouldThrow(InterruptedException.class) { + public void realRun() throws Exception { + c.await(LONG_DELAY_MS, MILLISECONDS); + }}; + Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) { + public void realRun() throws Exception { + c.await(LONG_DELAY_MS, MILLISECONDS); + }}; + + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + t1.interrupt(); + t1.join(); + t2.join(); } - + /** * A timeout in timed await throws TimeoutException */ - public void testAwait3_TimeOutException() { + public void testAwait3_TimeOutException() throws InterruptedException { final CyclicBarrier c = new CyclicBarrier(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(TimeoutException success){ - } catch(Exception b){ - threadUnexpectedException(); - - } - } - }); - try { - t.start(); - t.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread t = new ThreadShouldThrow(TimeoutException.class) { + public void realRun() throws Exception { + c.await(SHORT_DELAY_MS, MILLISECONDS); + }}; + + t.start(); + t.join(); } /** * A timeout in one party causes others waiting in timed await to * throw BrokenBarrierException */ - public void testAwait4_Timeout_BrokenBarrier() { + public void testAwait4_Timeout_BrokenBarrier() throws InterruptedException { final CyclicBarrier c = new CyclicBarrier(3); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(TimeoutException success){ - } catch(Exception b){ - threadUnexpectedException(); - } - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(BrokenBarrierException success){ - } catch(Exception i){ - threadUnexpectedException(); - } - } - }); - try { - t1.start(); - t2.start(); - t1.join(); - t2.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread t1 = new ThreadShouldThrow(TimeoutException.class) { + public void realRun() throws Exception { + c.await(SHORT_DELAY_MS, MILLISECONDS); + }}; + Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) { + public void realRun() throws Exception { + c.await(MEDIUM_DELAY_MS, MILLISECONDS); + }}; + + t1.start(); + t2.start(); + t1.join(); + t2.join(); } /** * A timeout in one party causes others waiting in await to * throw BrokenBarrierException */ - public void testAwait5_Timeout_BrokenBarrier() { + public void testAwait5_Timeout_BrokenBarrier() throws InterruptedException { final CyclicBarrier c = new CyclicBarrier(3); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(TimeoutException success){ - } catch(Exception b){ - threadUnexpectedException(); - } - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - c.await(); - threadShouldThrow(); - } catch(BrokenBarrierException success){ - } catch(Exception i){ - threadUnexpectedException(); - } - } - }); - try { - t1.start(); - t2.start(); - t1.join(); - t2.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread t1 = new ThreadShouldThrow(TimeoutException.class) { + public void realRun() throws Exception { + c.await(SHORT_DELAY_MS, MILLISECONDS); + }}; + Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) { + public void realRun() throws Exception { + c.await(); + }}; + + t1.start(); + t2.start(); + t1.join(); + t2.join(); } - + /** * A reset of an active barrier causes waiting threads to throw * BrokenBarrierException */ - public void testReset_BrokenBarrier() { + public void testReset_BrokenBarrier() throws InterruptedException { final CyclicBarrier c = new CyclicBarrier(3); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - c.await(); - threadShouldThrow(); - } catch(BrokenBarrierException success){} - catch(Exception b){ - threadUnexpectedException(); - } - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - c.await(); - threadShouldThrow(); - } catch(BrokenBarrierException success){ - } catch(Exception i){ - threadUnexpectedException(); - } - } - }); - try { - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - c.reset(); - t1.join(); - t2.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) { + public void realRun() throws Exception { + c.await(); + }}; + Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) { + public void realRun() throws Exception { + c.await(); + }}; + + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + c.reset(); + t1.join(); + t2.join(); } /** * A reset before threads enter barrier does not throw * BrokenBarrierException */ - public void testReset_NoBrokenBarrier() { + public void testReset_NoBrokenBarrier() throws Exception { final CyclicBarrier c = new CyclicBarrier(3); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - c.await(); - } catch(Exception b){ - threadUnexpectedException(); - } - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - c.await(); - } catch(Exception i){ - threadUnexpectedException(); - } - } - }); - try { - c.reset(); - t1.start(); - t2.start(); - c.await(); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws Exception { + c.await(); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws Exception { + c.await(); + }}); + + c.reset(); + t1.start(); + t2.start(); + c.await(); + t1.join(); + t2.join(); } /** * All threads block while a barrier is broken. */ - public void testReset_Leakage() { - try { - final CyclicBarrier c = new CyclicBarrier(2); - final AtomicBoolean done = new AtomicBoolean(); - Thread t = new Thread() { - public void run() { - while (!done.get()) { - try { - while (c.isBroken()) - c.reset(); - - c.await(); - threadFail("await should not return"); - } - catch (BrokenBarrierException e) { - } - catch (InterruptedException ie) { - } + public void testReset_Leakage() throws InterruptedException { + final CyclicBarrier c = new CyclicBarrier(2); + final AtomicBoolean done = new AtomicBoolean(); + Thread t = new Thread() { + public void run() { + while (!done.get()) { + try { + while (c.isBroken()) + c.reset(); + + c.await(); + threadFail("await should not return"); + } + catch (BrokenBarrierException e) { + } + catch (InterruptedException ie) { } } - }; - - t.start(); - for( int i = 0; i < 4; i++) { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - } - done.set(true); + } + }; + + t.start(); + for (int i = 0; i < 4; i++) { + Thread.sleep(SHORT_DELAY_MS); t.interrupt(); } - catch (Exception ex) { - unexpectedException(); - } + done.set(true); + t.interrupt(); + t.join(); } /** * Reset of a non-broken barrier does not break barrier */ - public void testResetWithoutBreakage() { - try { - final CyclicBarrier start = new CyclicBarrier(3); - final CyclicBarrier barrier = new CyclicBarrier(3); - for (int i = 0; i < 3; i++) { - Thread t1 = new Thread(new Runnable() { - public void run() { - try { start.await(); } - catch (Exception ie) { - threadFail("start barrier"); - } - try { barrier.await(); } - catch (Throwable thrown) { - unexpectedException(); - }}}); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { start.await(); } - catch (Exception ie) { - threadFail("start barrier"); - } - try { barrier.await(); } - catch (Throwable thrown) { - unexpectedException(); - }}}); - - - t1.start(); - t2.start(); - try { start.await(); } - catch (Exception ie) { threadFail("start barrier"); } - barrier.await(); - t1.join(); - t2.join(); - assertFalse(barrier.isBroken()); - assertEquals(0, barrier.getNumberWaiting()); - if (i == 1) barrier.reset(); - assertFalse(barrier.isBroken()); - assertEquals(0, barrier.getNumberWaiting()); - } - } - catch (Exception ex) { - unexpectedException(); + public void testResetWithoutBreakage() throws Exception { + final CyclicBarrier start = new CyclicBarrier(3); + final CyclicBarrier barrier = new CyclicBarrier(3); + for (int i = 0; i < 3; i++) { + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws Exception { + start.await(); + barrier.await(); + }}); + + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws Exception { + start.await(); + barrier.await(); + }}); + + t1.start(); + t2.start(); + start.await(); + barrier.await(); + t1.join(); + t2.join(); + assertFalse(barrier.isBroken()); + assertEquals(0, barrier.getNumberWaiting()); + if (i == 1) barrier.reset(); + assertFalse(barrier.isBroken()); + assertEquals(0, barrier.getNumberWaiting()); } } - + /** * Reset of a barrier after interruption reinitializes it. */ - public void testResetAfterInterrupt() { - try { - final CyclicBarrier start = new CyclicBarrier(3); - final CyclicBarrier barrier = new CyclicBarrier(3); - for (int i = 0; i < 2; i++) { - Thread t1 = new Thread(new Runnable() { - public void run() { - try { start.await(); } - catch (Exception ie) { - threadFail("start barrier"); - } - try { barrier.await(); } - catch(InterruptedException ok) {} - catch (Throwable thrown) { - unexpectedException(); - }}}); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { start.await(); } - catch (Exception ie) { - threadFail("start barrier"); - } - try { barrier.await(); } - catch(BrokenBarrierException ok) {} - catch (Throwable thrown) { - unexpectedException(); - }}}); - - t1.start(); - t2.start(); - try { start.await(); } - catch (Exception ie) { threadFail("start barrier"); } - t1.interrupt(); - t1.join(); - t2.join(); - assertTrue(barrier.isBroken()); - assertEquals(0, barrier.getNumberWaiting()); - barrier.reset(); - assertFalse(barrier.isBroken()); - assertEquals(0, barrier.getNumberWaiting()); - } - } - catch (Exception ex) { - unexpectedException(); + public void testResetAfterInterrupt() throws Exception { + final CyclicBarrier start = new CyclicBarrier(3); + final CyclicBarrier barrier = new CyclicBarrier(3); + for (int i = 0; i < 2; i++) { + Thread t1 = new ThreadShouldThrow(InterruptedException.class) { + public void realRun() throws Exception { + start.await(); + barrier.await(); + }}; + + Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) { + public void realRun() throws Exception { + start.await(); + barrier.await(); + }}; + + t1.start(); + t2.start(); + start.await(); + t1.interrupt(); + t1.join(); + t2.join(); + assertTrue(barrier.isBroken()); + assertEquals(0, barrier.getNumberWaiting()); + barrier.reset(); + assertFalse(barrier.isBroken()); + assertEquals(0, barrier.getNumberWaiting()); } } - + /** * Reset of a barrier after timeout reinitializes it. */ - public void testResetAfterTimeout() { - try { - final CyclicBarrier start = new CyclicBarrier(3); - final CyclicBarrier barrier = new CyclicBarrier(3); - for (int i = 0; i < 2; i++) { - Thread t1 = new Thread(new Runnable() { - public void run() { - try { start.await(); } - catch (Exception ie) { - threadFail("start barrier"); - } - try { barrier.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); } - catch(TimeoutException ok) {} - catch (Throwable thrown) { - unexpectedException(); - }}}); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { start.await(); } - catch (Exception ie) { - threadFail("start barrier"); - } - try { barrier.await(); } - catch(BrokenBarrierException ok) {} - catch (Throwable thrown) { - unexpectedException(); - }}}); - - t1.start(); - t2.start(); - try { start.await(); } - catch (Exception ie) { threadFail("start barrier"); } - t1.join(); - t2.join(); - assertTrue(barrier.isBroken()); - assertEquals(0, barrier.getNumberWaiting()); - barrier.reset(); - assertFalse(barrier.isBroken()); - assertEquals(0, barrier.getNumberWaiting()); - } - } - catch (Exception ex) { - unexpectedException(); + public void testResetAfterTimeout() throws Exception { + final CyclicBarrier start = new CyclicBarrier(3); + final CyclicBarrier barrier = new CyclicBarrier(3); + for (int i = 0; i < 2; i++) { + Thread t1 = new ThreadShouldThrow(TimeoutException.class) { + public void realRun() throws Exception { + start.await(); + barrier.await(MEDIUM_DELAY_MS, MILLISECONDS); + }}; + + Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) { + public void realRun() throws Exception { + start.await(); + barrier.await(); + }}; + + t1.start(); + t2.start(); + start.await(); + t1.join(); + t2.join(); + assertTrue(barrier.isBroken()); + assertEquals(0, barrier.getNumberWaiting()); + barrier.reset(); + assertFalse(barrier.isBroken()); + assertEquals(0, barrier.getNumberWaiting()); } } - + /** * Reset of a barrier after a failed command reinitializes it. */ - public void testResetAfterCommandException() { - try { - final CyclicBarrier start = new CyclicBarrier(3); - final CyclicBarrier barrier = - new CyclicBarrier(3, new Runnable() { - public void run() { - throw new NullPointerException(); }}); - for (int i = 0; i < 2; i++) { - Thread t1 = new Thread(new Runnable() { - public void run() { - try { start.await(); } - catch (Exception ie) { - threadFail("start barrier"); - } - try { barrier.await(); } - catch(BrokenBarrierException ok) {} - catch (Throwable thrown) { - unexpectedException(); - }}}); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { start.await(); } - catch (Exception ie) { - threadFail("start barrier"); - } - try { barrier.await(); } - catch(BrokenBarrierException ok) {} - catch (Throwable thrown) { - unexpectedException(); - }}}); - - t1.start(); - t2.start(); - try { start.await(); } - catch (Exception ie) { threadFail("start barrier"); } - while (barrier.getNumberWaiting() < 2) { Thread.yield(); } - try { barrier.await(); } - catch (Exception ok) { } - t1.join(); - t2.join(); - assertTrue(barrier.isBroken()); - assertEquals(0, barrier.getNumberWaiting()); - barrier.reset(); - assertFalse(barrier.isBroken()); - assertEquals(0, barrier.getNumberWaiting()); - } - } - catch (Exception ex) { - unexpectedException(); + public void testResetAfterCommandException() throws Exception { + final CyclicBarrier start = new CyclicBarrier(3); + final CyclicBarrier barrier = + new CyclicBarrier(3, new Runnable() { + public void run() { + throw new NullPointerException(); }}); + for (int i = 0; i < 2; i++) { + Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) { + public void realRun() throws Exception { + start.await(); + barrier.await(); + }}; + + Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) { + public void realRun() throws Exception { + start.await(); + barrier.await(); + }}; + + t1.start(); + t2.start(); + start.await(); + while (barrier.getNumberWaiting() < 2) { Thread.yield(); } + try { + barrier.await(); + shouldThrow(); + } catch (NullPointerException success) {} + t1.join(); + t2.join(); + assertTrue(barrier.isBroken()); + assertEquals(0, barrier.getNumberWaiting()); + barrier.reset(); + assertFalse(barrier.isBroken()); + assertEquals(0, barrier.getNumberWaiting()); } } } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/DelayQueueTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/DelayQueueTest.java index 3d851e8..7aeceda 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/DelayQueueTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/DelayQueueTest.java @@ -2,26 +2,27 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.util.concurrent.*; public class DelayQueueTest extends JSR166TestCase { public static Test suite() { - return new TestSuite(DelayQueueTest.class); + return new TestSuite(DelayQueueTest.class); } private static final int NOCAP = Integer.MAX_VALUE; /** * A delayed implementation for testing. - * Most tests use Pseudodelays, where delays are all elapsed + * Most tests use Pseudodelays, where delays are all elapsed * (so, no blocking solely for delays) but are still ordered */ static class PDelay implements Delayed { @@ -29,25 +30,21 @@ public class DelayQueueTest extends JSR166TestCase { PDelay(int i) { pseudodelay = Integer.MIN_VALUE + i; } public int compareTo(PDelay y) { int i = pseudodelay; - int j = ((PDelay)y).pseudodelay; + int j = y.pseudodelay; if (i < j) return -1; if (i > j) return 1; return 0; } public int compareTo(Delayed y) { - int i = pseudodelay; - int j = ((PDelay)y).pseudodelay; - if (i < j) return -1; - if (i > j) return 1; - return 0; + return compareTo((PDelay)y); } public boolean equals(Object other) { - return ((PDelay)other).pseudodelay == pseudodelay; + return equals((PDelay)other); } public boolean equals(PDelay other) { - return ((PDelay)other).pseudodelay == pseudodelay; + return other.pseudodelay == pseudodelay; } @@ -74,25 +71,21 @@ public class DelayQueueTest extends JSR166TestCase { } public int compareTo(NanoDelay y) { long i = trigger; - long j = ((NanoDelay)y).trigger; + long j = y.trigger; if (i < j) return -1; if (i > j) return 1; return 0; } public int compareTo(Delayed y) { - long i = trigger; - long j = ((NanoDelay)y).trigger; - if (i < j) return -1; - if (i > j) return 1; - return 0; + return compareTo((NanoDelay)y); } public boolean equals(Object other) { - return ((NanoDelay)other).trigger == trigger; + return equals((NanoDelay)other); } public boolean equals(NanoDelay other) { - return ((NanoDelay)other).trigger == trigger; + return other.trigger == trigger; } public long getDelay(TimeUnit unit) { @@ -117,13 +110,13 @@ public class DelayQueueTest extends JSR166TestCase { private DelayQueue populatedQueue(int n) { DelayQueue q = new DelayQueue(); assertTrue(q.isEmpty()); - for(int i = n-1; i >= 0; i-=2) - assertTrue(q.offer(new PDelay(i))); - for(int i = (n & 1); i < n; i+=2) - assertTrue(q.offer(new PDelay(i))); + for (int i = n-1; i >= 0; i-=2) + assertTrue(q.offer(new PDelay(i))); + for (int i = (n & 1); i < n; i+=2) + assertTrue(q.offer(new PDelay(i))); assertFalse(q.isEmpty()); assertEquals(NOCAP, q.remainingCapacity()); - assertEquals(n, q.size()); + assertEquals(n, q.size()); return q; } @@ -141,8 +134,7 @@ public class DelayQueueTest extends JSR166TestCase { try { DelayQueue q = new DelayQueue(null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -153,8 +145,7 @@ public class DelayQueueTest extends JSR166TestCase { PDelay[] ints = new PDelay[SIZE]; DelayQueue q = new DelayQueue(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -167,23 +158,19 @@ public class DelayQueueTest extends JSR166TestCase { ints[i] = new PDelay(i); DelayQueue q = new DelayQueue(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * Queue contains all elements of collection used to initialize */ public void testConstructor6() { - try { - PDelay[] ints = new PDelay[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new PDelay(i); - DelayQueue q = new DelayQueue(Arrays.asList(ints)); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); - } - finally {} + PDelay[] ints = new PDelay[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new PDelay(i); + DelayQueue q = new DelayQueue(Arrays.asList(ints)); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); } /** @@ -202,7 +189,7 @@ public class DelayQueueTest extends JSR166TestCase { } /** - * remainingCapacity does not change when elementa added or removed, + * remainingCapacity does not change when elements added or removed, * but size does */ public void testRemainingCapacity() { @@ -223,22 +210,22 @@ public class DelayQueueTest extends JSR166TestCase { * offer(null) throws NPE */ public void testOfferNull() { - try { + try { DelayQueue q = new DelayQueue(); q.offer(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** * add(null) throws NPE */ public void testAddNull() { - try { + try { DelayQueue q = new DelayQueue(); q.add(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -269,8 +256,7 @@ public class DelayQueueTest extends JSR166TestCase { DelayQueue q = new DelayQueue(); q.addAll(null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } @@ -282,8 +268,7 @@ public class DelayQueueTest extends JSR166TestCase { DelayQueue q = populatedQueue(SIZE); q.addAll(q); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } /** @@ -295,8 +280,7 @@ public class DelayQueueTest extends JSR166TestCase { PDelay[] ints = new PDelay[SIZE]; q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll of a collection with any null elements throws NPE after @@ -310,179 +294,133 @@ public class DelayQueueTest extends JSR166TestCase { ints[i] = new PDelay(i); q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * Queue contains all elements of successful addAll */ public void testAddAll5() { - try { - PDelay[] empty = new PDelay[0]; - PDelay[] ints = new PDelay[SIZE]; - for (int i = SIZE-1; i >= 0; --i) - ints[i] = new PDelay(i); - DelayQueue q = new DelayQueue(); - assertFalse(q.addAll(Arrays.asList(empty))); - assertTrue(q.addAll(Arrays.asList(ints))); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); - } - finally {} + PDelay[] empty = new PDelay[0]; + PDelay[] ints = new PDelay[SIZE]; + for (int i = SIZE-1; i >= 0; --i) + ints[i] = new PDelay(i); + DelayQueue q = new DelayQueue(); + assertFalse(q.addAll(Arrays.asList(empty))); + assertTrue(q.addAll(Arrays.asList(ints))); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); } /** * put(null) throws NPE */ public void testPutNull() { - try { + try { DelayQueue q = new DelayQueue(); q.put(null); shouldThrow(); - } - catch (NullPointerException success){ - } + } catch (NullPointerException success) {} } /** * all elements successfully put are contained */ public void testPut() { - try { - DelayQueue q = new DelayQueue(); - for (int i = 0; i < SIZE; ++i) { - PDelay I = new PDelay(i); - q.put(I); - assertTrue(q.contains(I)); - } - assertEquals(SIZE, q.size()); + DelayQueue q = new DelayQueue(); + for (int i = 0; i < SIZE; ++i) { + PDelay I = new PDelay(i); + q.put(I); + assertTrue(q.contains(I)); } - finally { - } + assertEquals(SIZE, q.size()); } /** * put doesn't block waiting for take */ - public void testPutWithTake() { + public void testPutWithTake() throws InterruptedException { final DelayQueue q = new DelayQueue(); - Thread t = new Thread(new Runnable() { - public void run() { - int added = 0; - try { - q.put(new PDelay(0)); - ++added; - q.put(new PDelay(0)); - ++added; - q.put(new PDelay(0)); - ++added; - q.put(new PDelay(0)); - ++added; - threadAssertTrue(added == 4); - } finally { - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - q.take(); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + q.put(new PDelay(0)); + q.put(new PDelay(0)); + q.put(new PDelay(0)); + q.put(new PDelay(0)); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + q.take(); + t.interrupt(); + t.join(); } /** * timed offer does not time out */ - public void testTimedOffer() { + public void testTimedOffer() throws InterruptedException { final DelayQueue q = new DelayQueue(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.put(new PDelay(0)); - q.put(new PDelay(0)); - threadAssertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(q.offer(new PDelay(0), LONG_DELAY_MS, TimeUnit.MILLISECONDS)); - } finally { } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.put(new PDelay(0)); + q.put(new PDelay(0)); + assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, MILLISECONDS)); + assertTrue(q.offer(new PDelay(0), LONG_DELAY_MS, MILLISECONDS)); + }}); - try { - t.start(); - Thread.sleep(SMALL_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + t.start(); + Thread.sleep(SMALL_DELAY_MS); + t.interrupt(); + t.join(); } /** * take retrieves elements in priority order */ - public void testTake() { - try { - DelayQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(new PDelay(i), ((PDelay)q.take())); - } - } catch (InterruptedException e){ - unexpectedException(); - } + public void testTake() throws InterruptedException { + DelayQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(new PDelay(i), ((PDelay)q.take())); + } } /** * take blocks interruptibly when empty */ - public void testTakeFromEmpty() { + public void testTakeFromEmpty() throws InterruptedException { final DelayQueue q = new DelayQueue(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.take(); - threadShouldThrow(); - } catch (InterruptedException success){ } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new ThreadShouldThrow(InterruptedException.class) { + public void realRun() throws InterruptedException { + q.take(); + }}; + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * Take removes existing elements until empty, then blocks interruptibly */ - public void testBlockingTake() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - DelayQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - threadAssertEquals(new PDelay(i), ((PDelay)q.take())); - } - q.take(); - threadShouldThrow(); - } catch (InterruptedException success){ - } - }}); + public void testBlockingTake() throws InterruptedException { + final DelayQueue q = populatedQueue(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) { + assertEquals(new PDelay(i), ((PDelay)q.take())); + } + try { + q.take(); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } @@ -494,91 +432,76 @@ public class DelayQueueTest extends JSR166TestCase { for (int i = 0; i < SIZE; ++i) { assertEquals(new PDelay(i), ((PDelay)q.poll())); } - assertNull(q.poll()); + assertNull(q.poll()); } /** * timed pool with zero timeout succeeds when non-empty, else times out */ - public void testTimedPoll0() { - try { - DelayQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(new PDelay(i), ((PDelay)q.poll(0, TimeUnit.MILLISECONDS))); - } - assertNull(q.poll(0, TimeUnit.MILLISECONDS)); - } catch (InterruptedException e){ - unexpectedException(); - } + public void testTimedPoll0() throws InterruptedException { + DelayQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(new PDelay(i), ((PDelay)q.poll(0, MILLISECONDS))); + } + assertNull(q.poll(0, MILLISECONDS)); } /** * timed pool with nonzero timeout succeeds when non-empty, else times out */ - public void testTimedPoll() { - try { - DelayQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS))); - } - assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (InterruptedException e){ - unexpectedException(); - } + public void testTimedPoll() throws InterruptedException { + DelayQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS))); + } + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); } /** * Interrupted timed poll throws InterruptedException instead of * returning timeout status */ - public void testInterruptedTimedPoll() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - DelayQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - threadAssertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS))); - } - threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (InterruptedException success){ - } - }}); + public void testInterruptedTimedPoll() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + DelayQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS))); + } + try { + q.poll(SMALL_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * timed poll before a delayed offer fails; after offer succeeds; * on interruption throws */ - public void testTimedPollWithOffer() { + public void testTimedPollWithOffer() throws InterruptedException { final DelayQueue q = new DelayQueue(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadFail("Should block"); - } catch (InterruptedException success) { } - } - }); - try { - t.start(); - Thread.sleep(SMALL_DELAY_MS); - assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + final PDelay pdelay = new PDelay(0); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); + assertSame(pdelay, q.poll(LONG_DELAY_MS, MILLISECONDS)); + try { + q.poll(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + assertTrue(q.offer(pdelay, SHORT_DELAY_MS, MILLISECONDS)); + t.interrupt(); + t.join(); } @@ -589,13 +512,13 @@ public class DelayQueueTest extends JSR166TestCase { DelayQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { assertEquals(new PDelay(i), ((PDelay)q.peek())); - q.poll(); + assertEquals(new PDelay(i), ((PDelay)q.poll())); if (q.isEmpty()) assertNull(q.peek()); else - assertTrue(i != ((PDelay)q.peek()).intValue()); + assertFalse(new PDelay(i).equals(q.peek())); } - assertNull(q.peek()); + assertNull(q.peek()); } /** @@ -610,8 +533,7 @@ public class DelayQueueTest extends JSR166TestCase { try { q.element(); shouldThrow(); - } - catch (NoSuchElementException success) {} + } catch (NoSuchElementException success) {} } /** @@ -625,8 +547,7 @@ public class DelayQueueTest extends JSR166TestCase { try { q.remove(); shouldThrow(); - } catch (NoSuchElementException success){ - } + } catch (NoSuchElementException success) {} } /** @@ -725,32 +646,24 @@ public class DelayQueueTest extends JSR166TestCase { /** * toArray contains all elements */ - public void testToArray() { + public void testToArray() throws InterruptedException { DelayQueue q = populatedQueue(SIZE); - Object[] o = q.toArray(); + Object[] o = q.toArray(); Arrays.sort(o); - try { - for(int i = 0; i < o.length; i++) - assertEquals(o[i], q.take()); - } catch (InterruptedException e){ - unexpectedException(); - } + for (int i = 0; i < o.length; i++) + assertEquals(o[i], q.take()); } /** * toArray(a) contains all elements */ - public void testToArray2() { + public void testToArray2() throws InterruptedException { DelayQueue q = populatedQueue(SIZE); - PDelay[] ints = new PDelay[SIZE]; - ints = (PDelay[])q.toArray(ints); + PDelay[] ints = new PDelay[SIZE]; + ints = (PDelay[])q.toArray(ints); Arrays.sort(ints); - try { - for(int i = 0; i < ints.length; i++) - assertEquals(ints[i], q.take()); - } catch (InterruptedException e){ - unexpectedException(); - } + for (int i = 0; i < ints.length; i++) + assertEquals(ints[i], q.take()); } @@ -758,22 +671,22 @@ public class DelayQueueTest extends JSR166TestCase { * toArray(null) throws NPE */ public void testToArray_BadArg() { - try { - DelayQueue q = populatedQueue(SIZE); - Object o[] = q.toArray(null); - shouldThrow(); - } catch(NullPointerException success){} + DelayQueue q = populatedQueue(SIZE); + try { + Object o[] = q.toArray(null); + shouldThrow(); + } catch (NullPointerException success) {} } /** * toArray with incompatible array type throws CCE */ public void testToArray1_BadArg() { - try { - DelayQueue q = populatedQueue(SIZE); - Object o[] = q.toArray(new String[10] ); - shouldThrow(); - } catch(ArrayStoreException success){} + DelayQueue q = populatedQueue(SIZE); + try { + Object o[] = q.toArray(new String[10]); + shouldThrow(); + } catch (ArrayStoreException success) {} } /** @@ -782,8 +695,8 @@ public class DelayQueueTest extends JSR166TestCase { public void testIterator() { DelayQueue q = populatedQueue(SIZE); int i = 0; - Iterator it = q.iterator(); - while(it.hasNext()) { + Iterator it = q.iterator(); + while (it.hasNext()) { assertTrue(q.contains(it.next())); ++i; } @@ -825,39 +738,27 @@ public class DelayQueueTest extends JSR166TestCase { public void testPollInExecutor() { final DelayQueue q = new DelayQueue(); ExecutorService executor = Executors.newFixedThreadPool(2); - executor.execute(new Runnable() { - public void run() { - threadAssertNull(q.poll()); - try { - threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(q.isEmpty()); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll()); + assertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS)); + assertTrue(q.isEmpty()); + }}); + + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SHORT_DELAY_MS); + q.put(new PDelay(1)); + }}); - executor.execute(new Runnable() { - public void run() { - try { - Thread.sleep(SHORT_DELAY_MS); - q.put(new PDelay(1)); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); joinPool(executor); - } /** * Delayed actions do not occur until their delay elapses */ - public void testDelay() { + public void testDelay() throws InterruptedException { DelayQueue q = new DelayQueue(); NanoDelay[] elements = new NanoDelay[SIZE]; for (int i = 0; i < SIZE; ++i) { @@ -867,19 +768,14 @@ public class DelayQueueTest extends JSR166TestCase { q.add(elements[i]); } - try { - long last = 0; - for (int i = 0; i < SIZE; ++i) { - NanoDelay e = (NanoDelay)(q.take()); - long tt = e.getTriggerTime(); - assertTrue(tt <= System.nanoTime()); - if (i != 0) - assertTrue(tt >= last); - last = tt; - } - } - catch(InterruptedException ie) { - unexpectedException(); + long last = 0; + for (int i = 0; i < SIZE; ++i) { + NanoDelay e = (NanoDelay)(q.take()); + long tt = e.getTriggerTime(); + assertTrue(tt <= System.nanoTime()); + if (i != 0) + assertTrue(tt >= last); + last = tt; } } @@ -905,14 +801,10 @@ public class DelayQueueTest extends JSR166TestCase { /** * timed poll of a non-empty queue returns null if no expired elements. */ - public void testTimedPollDelayed() { + public void testTimedPollDelayed() throws InterruptedException { DelayQueue q = new DelayQueue(); q.add(new NanoDelay(LONG_DELAY_MS * 1000000L)); - try { - assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (Exception ex) { - unexpectedException(); - } + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); } /** @@ -923,8 +815,7 @@ public class DelayQueueTest extends JSR166TestCase { try { q.drainTo(null); shouldThrow(); - } catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** @@ -935,8 +826,7 @@ public class DelayQueueTest extends JSR166TestCase { try { q.drainTo(q); shouldThrow(); - } catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } /** @@ -969,53 +859,47 @@ public class DelayQueueTest extends JSR166TestCase { /** * drainTo empties queue - */ - public void testDrainToWithActivePut() { + */ + public void testDrainToWithActivePut() throws InterruptedException { final DelayQueue q = populatedQueue(SIZE); - Thread t = new Thread(new Runnable() { - public void run() { - q.put(new PDelay(SIZE+1)); - } - }); - try { - t.start(); - ArrayList l = new ArrayList(); - q.drainTo(l); - assertTrue(l.size() >= SIZE); - t.join(); - assertTrue(q.size() + l.size() >= SIZE); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + q.put(new PDelay(SIZE+1)); + }}); + + t.start(); + ArrayList l = new ArrayList(); + q.drainTo(l); + assertTrue(l.size() >= SIZE); + t.join(); + assertTrue(q.size() + l.size() >= SIZE); } /** * drainTo(null, n) throws NPE - */ + */ public void testDrainToNullN() { DelayQueue q = populatedQueue(SIZE); try { q.drainTo(null, 0); shouldThrow(); - } catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * drainTo(this, n) throws IAE - */ + */ public void testDrainToSelfN() { DelayQueue q = populatedQueue(SIZE); try { q.drainTo(q, 0); shouldThrow(); - } catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } /** * drainTo(c, n) empties first max {n, size} elements of queue into c - */ + */ public void testDrainToN() { for (int i = 0; i < SIZE + 2; ++i) { DelayQueue q = populatedQueue(SIZE); diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/EntryTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/EntryTest.java new file mode 100644 index 0000000..893fd48 --- /dev/null +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/EntryTest.java @@ -0,0 +1,131 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + */ + +package tests.api.java.util.concurrent; // android-added + +import junit.framework.*; +import java.util.*; +import java.util.concurrent.*; +import java.io.*; + +public class EntryTest extends JSR166TestCase { + public static Test suite() { + return new TestSuite(EntryTest.class); + } + + static final String k1 = "1"; + static final String v1 = "a"; + static final String k2 = "2"; + static final String v2 = "b"; + + + /** + * A new SimpleEntry(k, v) holds k, v. + */ + public void testConstructor1() { + Map.Entry e = new AbstractMap.SimpleEntry(k1, v1); + assertEquals(k1, e.getKey()); + assertEquals(v1, e.getValue()); + } + + /** + * A new SimpleImmutableEntry(k, v) holds k, v. + */ + public void testConstructor2() { + Map.Entry s = new AbstractMap.SimpleImmutableEntry(k1, v1); + assertEquals(k1, s.getKey()); + assertEquals(v1, s.getValue()); + } + + + /** + * A new SimpleEntry(entry(k, v)) holds k, v. + */ + public void testConstructor3() { + Map.Entry e2 = new AbstractMap.SimpleEntry(k1, v1); + Map.Entry e = new AbstractMap.SimpleEntry(e2); + assertEquals(k1, e.getKey()); + assertEquals(v1, e.getValue()); + } + + /** + * A new SimpleImmutableEntry(entry(k, v)) holds k, v. + */ + public void testConstructor4() { + Map.Entry s2 = new AbstractMap.SimpleImmutableEntry(k1, v1); + Map.Entry s = new AbstractMap.SimpleImmutableEntry(s2); + assertEquals(k1, s.getKey()); + assertEquals(v1, s.getValue()); + } + + /** + * Entries with same key-value pairs are equal and have same + * hashcodes + */ + public void testEquals() { + Map.Entry e2 = new AbstractMap.SimpleEntry(k1, v1); + Map.Entry e = new AbstractMap.SimpleEntry(e2); + Map.Entry s2 = new AbstractMap.SimpleImmutableEntry(k1, v1); + Map.Entry s = new AbstractMap.SimpleImmutableEntry(s2); + assertEquals(e2, e); + assertEquals(e2.hashCode(), e.hashCode()); + assertEquals(s2, s); + assertEquals(s2.hashCode(), s.hashCode()); + assertEquals(e2, s2); + assertEquals(e2.hashCode(), s2.hashCode()); + assertEquals(e, s); + assertEquals(e.hashCode(), s.hashCode()); + } + + /** + * Entries with different key-value pairs are not equal + */ + public void testNotEquals() { + Map.Entry e2 = new AbstractMap.SimpleEntry(k1, v1); + Map.Entry e = new AbstractMap.SimpleEntry(k2, v1); + assertFalse(e2.equals( e)); + e = new AbstractMap.SimpleEntry(k1, v2); + assertFalse(e2.equals( e)); + e = new AbstractMap.SimpleEntry(k2, v2); + assertFalse(e2.equals( e)); + + Map.Entry s2 = new AbstractMap.SimpleImmutableEntry(k1, v1); + Map.Entry s = new AbstractMap.SimpleImmutableEntry(k2, v1); + assertFalse(s2.equals( s)); + s = new AbstractMap.SimpleImmutableEntry(k1, v2); + assertFalse(s2.equals( s)); + s = new AbstractMap.SimpleImmutableEntry(k2, v2); + assertFalse(s2.equals( s)); + } + + + /** + * getValue returns last setValue for SimpleEntry + */ + public void testSetValue1() { + Map.Entry e2 = new AbstractMap.SimpleEntry(k1, v1); + Map.Entry e = new AbstractMap.SimpleEntry(e2); + assertEquals(k1, e.getKey()); + assertEquals(v1, e.getValue()); + e.setValue(k2); + assertEquals(k2, e.getValue()); + assertFalse(e2.equals( e)); + } + + /** + * setValue for SimpleImmutableEntry throws UnsupportedOperationException + */ + public void testsetValue2() { + Map.Entry s2 = new AbstractMap.SimpleImmutableEntry(k1, v1); + Map.Entry s = new AbstractMap.SimpleImmutableEntry(s2); + assertEquals(k1, s.getKey()); + assertEquals(v1, s.getValue()); + try { + s.setValue(k2); + shouldThrow(); + } catch (UnsupportedOperationException success) {} + } +} diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ExchangerTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ExchangerTest.java index bc0df85..be1eaa3 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ExchangerTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ExchangerTest.java @@ -2,15 +2,16 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; public class ExchangerTest extends JSR166TestCase { public static Test suite() { @@ -20,211 +21,123 @@ public class ExchangerTest extends JSR166TestCase { /** * exchange exchanges objects across two threads */ - public void testExchange() { + public void testExchange() throws InterruptedException { final Exchanger e = new Exchanger(); - Thread t1 = new Thread(new Runnable(){ - public void run(){ - try { - Object v = e.exchange(one); - threadAssertEquals(v, two); - Object w = e.exchange(v); - threadAssertEquals(w, one); - } catch(InterruptedException e){ - threadUnexpectedException(); - } - } - }); - Thread t2 = new Thread(new Runnable(){ - public void run(){ - try { - Object v = e.exchange(two); - threadAssertEquals(v, one); - Object w = e.exchange(v); - threadAssertEquals(w, two); - } catch(InterruptedException e){ - threadUnexpectedException(); - } - } - }); - try { - t1.start(); - t2.start(); - t1.join(); - t2.join(); - } catch(InterruptedException ex) { - unexpectedException(); - } + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertSame(one, e.exchange(two)); + assertSame(two, e.exchange(one)); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertSame(two, e.exchange(one)); + assertSame(one, e.exchange(two)); + }}); + + t1.start(); + t2.start(); + t1.join(); + t2.join(); } /** * timed exchange exchanges objects across two threads */ - public void testTimedExchange() { + public void testTimedExchange() throws InterruptedException { final Exchanger e = new Exchanger(); - Thread t1 = new Thread(new Runnable(){ - public void run(){ - try { - Object v = e.exchange(one, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - threadAssertEquals(v, two); - Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - threadAssertEquals(w, one); - } catch(InterruptedException e){ - threadUnexpectedException(); - } catch(TimeoutException toe) { - threadUnexpectedException(); - } - } - }); - Thread t2 = new Thread(new Runnable(){ - public void run(){ - try { - Object v = e.exchange(two, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - threadAssertEquals(v, one); - Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - threadAssertEquals(w, two); - } catch(InterruptedException e){ - threadUnexpectedException(); - } catch(TimeoutException toe) { - threadUnexpectedException(); - } - } - }); - try { - t1.start(); - t2.start(); - t1.join(); - t2.join(); - } catch(InterruptedException ex) { - unexpectedException(); - } + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws Exception { + assertSame(one, e.exchange(two, SHORT_DELAY_MS, MILLISECONDS)); + assertSame(two, e.exchange(one, SHORT_DELAY_MS, MILLISECONDS)); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws Exception { + assertSame(two, e.exchange(one, SHORT_DELAY_MS, MILLISECONDS)); + assertSame(one, e.exchange(two, SHORT_DELAY_MS, MILLISECONDS)); + }}); + + t1.start(); + t2.start(); + t1.join(); + t2.join(); } /** * interrupt during wait for exchange throws IE */ - public void testExchange_InterruptedException(){ + public void testExchange_InterruptedException() throws InterruptedException { final Exchanger e = new Exchanger(); - Thread t = new Thread(new Runnable() { - public void run(){ - try { - e.exchange(one); - threadShouldThrow(); - } catch(InterruptedException success){ - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(InterruptedException ex) { - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + e.exchange(one); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * interrupt during wait for timed exchange throws IE */ - public void testTimedExchange_InterruptedException(){ + public void testTimedExchange_InterruptedException() throws InterruptedException { final Exchanger e = new Exchanger(); - Thread t = new Thread(new Runnable() { - public void run(){ - try { - e.exchange(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(InterruptedException success){ - } catch(Exception e2){ - threadFail("should throw IE"); - } - } - }); - try { - t.start(); - t.interrupt(); - t.join(); - } catch(InterruptedException ex){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws Exception { + e.exchange(null, SMALL_DELAY_MS, MILLISECONDS); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * timeout during wait for timed exchange throws TOE */ - public void testExchange_TimeOutException(){ + public void testExchange_TimeOutException() throws InterruptedException { final Exchanger e = new Exchanger(); - Thread t = new Thread(new Runnable() { - public void run(){ - try { - e.exchange(null, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(TimeoutException success){ - } catch(InterruptedException e2){ - threadFail("should throw TOE"); - } - } - }); - try { - t.start(); - t.join(); - } catch(InterruptedException ex){ - unexpectedException(); - } + Thread t = new ThreadShouldThrow(TimeoutException.class) { + public void realRun() throws Exception { + e.exchange(null, SHORT_DELAY_MS, MILLISECONDS); + }}; + + t.start(); + t.join(); } /** * If one exchanging thread is interrupted, another succeeds. */ - public void testReplacementAfterExchange() { + public void testReplacementAfterExchange() throws InterruptedException { final Exchanger e = new Exchanger(); - Thread t1 = new Thread(new Runnable(){ - public void run(){ - try { - Object v = e.exchange(one); - threadAssertEquals(v, two); - Object w = e.exchange(v); - threadShouldThrow(); - } catch(InterruptedException success){ - } - } - }); - Thread t2 = new Thread(new Runnable(){ - public void run(){ - try { - Object v = e.exchange(two); - threadAssertEquals(v, one); - Thread.sleep(SMALL_DELAY_MS); - Object w = e.exchange(v); - threadAssertEquals(w, three); - } catch(InterruptedException e){ - threadUnexpectedException(); - } - } - }); - Thread t3 = new Thread(new Runnable(){ - public void run(){ - try { - Thread.sleep(SMALL_DELAY_MS); - Object w = e.exchange(three); - threadAssertEquals(w, one); - } catch(InterruptedException e){ - threadUnexpectedException(); - } - } - }); - - try { - t1.start(); - t2.start(); - t3.start(); - Thread.sleep(SHORT_DELAY_MS); - t1.interrupt(); - t1.join(); - t2.join(); - t3.join(); - } catch(InterruptedException ex) { - unexpectedException(); - } + Thread t1 = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + assertSame(two, e.exchange(one)); + e.exchange(two); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertSame(one, e.exchange(two)); + Thread.sleep(SMALL_DELAY_MS); + assertSame(three, e.exchange(one)); + }}); + Thread t3 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); + assertSame(one, e.exchange(three)); + }}); + + t1.start(); + t2.start(); + t3.start(); + Thread.sleep(SHORT_DELAY_MS); + t1.interrupt(); + t1.join(); + t2.join(); + t3.join(); } } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ExecutorCompletionServiceTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ExecutorCompletionServiceTest.java index 91bedf9..dfa8f7d 100644 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ExecutorCompletionServiceTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ExecutorCompletionServiceTest.java @@ -2,20 +2,21 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.util.concurrent.atomic.*; import java.math.BigInteger; import java.security.*; -public class ExecutorCompletionServiceTest extends JSR166TestCase{ +public class ExecutorCompletionServiceTest extends JSR166TestCase { public static Test suite() { return new TestSuite(ExecutorCompletionServiceTest.class); } @@ -23,30 +24,28 @@ public class ExecutorCompletionServiceTest extends JSR166TestCase{ /** * Creating a new ECS with null Executor throw NPE - */ + */ public void testConstructorNPE() { try { ExecutorCompletionService ecs = new ExecutorCompletionService(null); shouldThrow(); - } catch (NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * Creating a new ECS with null queue throw NPE - */ + */ public void testConstructorNPE2() { try { ExecutorService e = Executors.newCachedThreadPool(); ExecutorCompletionService ecs = new ExecutorCompletionService(e, null); shouldThrow(); - } catch (NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * Submitting a null callable throws NPE - */ + */ public void testSubmitNPE() { ExecutorService e = Executors.newCachedThreadPool(); ExecutorCompletionService ecs = new ExecutorCompletionService(e); @@ -62,7 +61,7 @@ public class ExecutorCompletionServiceTest extends JSR166TestCase{ /** * Submitting a null runnable throws NPE - */ + */ public void testSubmitNPE2() { ExecutorService e = Executors.newCachedThreadPool(); ExecutorCompletionService ecs = new ExecutorCompletionService(e); @@ -78,8 +77,8 @@ public class ExecutorCompletionServiceTest extends JSR166TestCase{ /** * A taken submitted task is completed - */ - public void testTake() { + */ + public void testTake() throws InterruptedException { ExecutorService e = Executors.newCachedThreadPool(); ExecutorCompletionService ecs = new ExecutorCompletionService(e); try { @@ -87,8 +86,6 @@ public class ExecutorCompletionServiceTest extends JSR166TestCase{ ecs.submit(c); Future f = ecs.take(); assertTrue(f.isDone()); - } catch (Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -96,8 +93,8 @@ public class ExecutorCompletionServiceTest extends JSR166TestCase{ /** * Take returns the same future object returned by submit - */ - public void testTake2() { + */ + public void testTake2() throws InterruptedException { ExecutorService e = Executors.newCachedThreadPool(); ExecutorCompletionService ecs = new ExecutorCompletionService(e); try { @@ -105,8 +102,6 @@ public class ExecutorCompletionServiceTest extends JSR166TestCase{ Future f1 = ecs.submit(c); Future f2 = ecs.take(); assertSame(f1, f2); - } catch (Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -114,8 +109,8 @@ public class ExecutorCompletionServiceTest extends JSR166TestCase{ /** * If poll returns non-null, the returned task is completed - */ - public void testPoll1() { + */ + public void testPoll1() throws InterruptedException { ExecutorService e = Executors.newCachedThreadPool(); ExecutorCompletionService ecs = new ExecutorCompletionService(e); try { @@ -130,8 +125,6 @@ public class ExecutorCompletionServiceTest extends JSR166TestCase{ break; } } - } catch (Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -139,21 +132,85 @@ public class ExecutorCompletionServiceTest extends JSR166TestCase{ /** * If timed poll returns non-null, the returned task is completed - */ - public void testPoll2() { + */ + public void testPoll2() throws InterruptedException { ExecutorService e = Executors.newCachedThreadPool(); ExecutorCompletionService ecs = new ExecutorCompletionService(e); try { assertNull(ecs.poll()); Callable c = new StringTask(); ecs.submit(c); - Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - if (f != null) + Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS); + if (f != null) assertTrue(f.isDone()); - } catch (Exception ex) { - unexpectedException(); } finally { joinPool(e); } } + /** + * Submitting to underlying AES that overrides newTaskFor(Callable) + * returns and eventually runs Future returned by newTaskFor. + */ + public void testNewTaskForCallable() throws InterruptedException { + final AtomicBoolean done = new AtomicBoolean(false); + class MyCallableFuture<V> extends FutureTask<V> { + MyCallableFuture(Callable<V> c) { super(c); } + protected void done() { done.set(true); } + } + ExecutorService e = new ThreadPoolExecutor( + 1, 1, 30L, TimeUnit.SECONDS, + new ArrayBlockingQueue<Runnable>(1)) { + protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) { + return new MyCallableFuture<T>(c); + } + }; + ExecutorCompletionService<String> ecs = + new ExecutorCompletionService<String>(e); + try { + assertNull(ecs.poll()); + Callable<String> c = new StringTask(); + Future f1 = ecs.submit(c); + assertTrue("submit must return MyCallableFuture", + f1 instanceof MyCallableFuture); + Future f2 = ecs.take(); + assertSame("submit and take must return same objects", f1, f2); + assertTrue("completed task must have set done", done.get()); + } finally { + joinPool(e); + } + } + + /** + * Submitting to underlying AES that overrides newTaskFor(Runnable,T) + * returns and eventually runs Future returned by newTaskFor. + */ + public void testNewTaskForRunnable() throws InterruptedException { + final AtomicBoolean done = new AtomicBoolean(false); + class MyRunnableFuture<V> extends FutureTask<V> { + MyRunnableFuture(Runnable t, V r) { super(t, r); } + protected void done() { done.set(true); } + } + ExecutorService e = new ThreadPoolExecutor( + 1, 1, 30L, TimeUnit.SECONDS, + new ArrayBlockingQueue<Runnable>(1)) { + protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) { + return new MyRunnableFuture<T>(t, r); + } + }; + ExecutorCompletionService<String> ecs = + new ExecutorCompletionService<String>(e); + try { + assertNull(ecs.poll()); + Runnable r = new NoOpRunnable(); + Future f1 = ecs.submit(r, null); + assertTrue("submit must return MyRunnableFuture", + f1 instanceof MyRunnableFuture); + Future f2 = ecs.take(); + assertSame("submit and take must return same objects", f1, f2); + assertTrue("completed task must have set done", done.get()); + } finally { + joinPool(e); + } + } + } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ExecutorsTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ExecutorsTest.java index b0a2ccd..f29a712 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ExecutorsTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ExecutorsTest.java @@ -2,63 +2,24 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.math.BigInteger; import java.security.*; -public class ExecutorsTest extends JSR166TestCase{ +public class ExecutorsTest extends JSR166TestCase { public static Test suite() { return new TestSuite(ExecutorsTest.class); } - static class TimedCallable<T> implements Callable<T> { - private final ExecutorService exec; - private final Callable<T> func; - private final long msecs; - - TimedCallable(ExecutorService exec, Callable<T> func, long msecs) { - this.exec = exec; - this.func = func; - this.msecs = msecs; - } - - public T call() throws Exception { - Future<T> ftask = exec.submit(func); - try { - return ftask.get(msecs, TimeUnit.MILLISECONDS); - } finally { - ftask.cancel(true); - } - } - } - - - private static class Fib implements Callable<BigInteger> { - private final BigInteger n; - Fib(long n) { - if (n < 0) throw new IllegalArgumentException("need non-negative arg, but got " + n); - this.n = BigInteger.valueOf(n); - } - public BigInteger call() { - BigInteger f1 = BigInteger.ONE; - BigInteger f2 = f1; - for (BigInteger i = BigInteger.ZERO; i.compareTo(n) < 0; i = i.add(BigInteger.ONE)) { - BigInteger t = f1.add(f2); - f1 = f2; - f2 = t; - } - return f1; - } - }; - /** * A newCachedThreadPool can execute runnables */ @@ -88,9 +49,7 @@ public class ExecutorsTest extends JSR166TestCase{ try { ExecutorService e = Executors.newCachedThreadPool(null); shouldThrow(); - } - catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } @@ -123,9 +82,7 @@ public class ExecutorsTest extends JSR166TestCase{ try { ExecutorService e = Executors.newSingleThreadExecutor(null); shouldThrow(); - } - catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** @@ -135,6 +92,7 @@ public class ExecutorsTest extends JSR166TestCase{ ExecutorService e = Executors.newSingleThreadExecutor(); try { ThreadPoolExecutor tpe = (ThreadPoolExecutor)e; + shouldThrow(); } catch (ClassCastException success) { } finally { joinPool(e); @@ -171,9 +129,7 @@ public class ExecutorsTest extends JSR166TestCase{ try { ExecutorService e = Executors.newFixedThreadPool(2, null); shouldThrow(); - } - catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** @@ -183,9 +139,7 @@ public class ExecutorsTest extends JSR166TestCase{ try { ExecutorService e = Executors.newFixedThreadPool(0); shouldThrow(); - } - catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } @@ -206,9 +160,8 @@ public class ExecutorsTest extends JSR166TestCase{ public void testunconfigurableExecutorServiceNPE() { try { ExecutorService e = Executors.unconfigurableExecutorService(null); - } - catch (NullPointerException success) { - } + shouldThrow(); + } catch (NullPointerException success) {} } /** @@ -217,109 +170,82 @@ public class ExecutorsTest extends JSR166TestCase{ public void testunconfigurableScheduledExecutorServiceNPE() { try { ExecutorService e = Executors.unconfigurableScheduledExecutorService(null); - } - catch (NullPointerException success) { - } + shouldThrow(); + } catch (NullPointerException success) {} } /** * a newSingleThreadScheduledExecutor successfully runs delayed task */ - public void testNewSingleThreadScheduledExecutor() { - try { - TrackedCallable callable = new TrackedCallable(); - ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor(); - Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - assertFalse(callable.done); - Thread.sleep(MEDIUM_DELAY_MS); - assertTrue(callable.done); - assertEquals(Boolean.TRUE, f.get()); - joinPool(p1); - } catch(RejectedExecutionException e){} - catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + public void testNewSingleThreadScheduledExecutor() throws Exception { + TrackedCallable callable = new TrackedCallable(); + ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor(); + Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS); + assertFalse(callable.done); + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(callable.done); + assertEquals(Boolean.TRUE, f.get()); + joinPool(p1); } /** * a newScheduledThreadPool successfully runs delayed task */ - public void testnewScheduledThreadPool() { - try { - TrackedCallable callable = new TrackedCallable(); - ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2); - Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - assertFalse(callable.done); - Thread.sleep(MEDIUM_DELAY_MS); - assertTrue(callable.done); - assertEquals(Boolean.TRUE, f.get()); - joinPool(p1); - } catch(RejectedExecutionException e){} - catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + public void testnewScheduledThreadPool() throws Exception { + TrackedCallable callable = new TrackedCallable(); + ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2); + Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS); + assertFalse(callable.done); + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(callable.done); + assertEquals(Boolean.TRUE, f.get()); + joinPool(p1); } /** - * an unconfigurable newScheduledThreadPool successfully runs delayed task + * an unconfigurable newScheduledThreadPool successfully runs delayed task */ - public void testunconfigurableScheduledExecutorService() { - try { - TrackedCallable callable = new TrackedCallable(); - ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2)); - Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - assertFalse(callable.done); - Thread.sleep(MEDIUM_DELAY_MS); - assertTrue(callable.done); - assertEquals(Boolean.TRUE, f.get()); - joinPool(p1); - } catch(RejectedExecutionException e){} - catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + public void testunconfigurableScheduledExecutorService() throws Exception { + TrackedCallable callable = new TrackedCallable(); + ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2)); + Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS); + assertFalse(callable.done); + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(callable.done); + assertEquals(Boolean.TRUE, f.get()); + joinPool(p1); } /** - * timeouts from execute will time out if they compute too long. + * Future.get on submitted tasks will time out if they compute too long. */ - public void testTimedCallable() { - int N = 10000; - ExecutorService executor = Executors.newSingleThreadExecutor(); - List<Callable<BigInteger>> tasks = new ArrayList<Callable<BigInteger>>(N); - try { - long startTime = System.currentTimeMillis(); - - long i = 0; - while (tasks.size() < N) { - tasks.add(new TimedCallable<BigInteger>(executor, new Fib(i), 1)); - i += 10; - } - - int iters = 0; - BigInteger sum = BigInteger.ZERO; - for (Iterator<Callable<BigInteger>> it = tasks.iterator(); it.hasNext();) { + public void testTimedCallable() throws Exception { + final Runnable sleeper = + new RunnableShouldThrow(InterruptedException.class) { + public void realRun() throws InterruptedException { + Thread.sleep(LONG_DELAY_MS); + }}; + for (ExecutorService executor : + new ExecutorService[] { + Executors.newSingleThreadExecutor(), + Executors.newCachedThreadPool(), + Executors.newFixedThreadPool(2), + Executors.newScheduledThreadPool(2), + }) { + try { + Future future = executor.submit(sleeper); try { - ++iters; - sum = sum.add(it.next().call()); - } - catch (TimeoutException success) { - assertTrue(iters > 0); - return; - } - catch (Exception e) { - unexpectedException(); + future.get(SHORT_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (TimeoutException success) { + } finally { + future.cancel(true); } } - // if by chance we didn't ever time out, total time must be small - long elapsed = System.currentTimeMillis() - startTime; - assertTrue(elapsed < N); - } - finally { - joinPool(executor); + finally { + joinPool(executor); + } } } @@ -328,25 +254,25 @@ public class ExecutorsTest extends JSR166TestCase{ * ThreadPoolExecutor using defaultThreadFactory has * specified group, priority, daemon status, and name */ - public void testDefaultThreadFactory() { + public void testDefaultThreadFactory() throws Exception { final ThreadGroup egroup = Thread.currentThread().getThreadGroup(); Runnable r = new Runnable() { public void run() { - try { - Thread current = Thread.currentThread(); - threadAssertTrue(!current.isDaemon()); - threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY); - ThreadGroup g = current.getThreadGroup(); - SecurityManager s = System.getSecurityManager(); - if (s != null) - threadAssertTrue(g == s.getThreadGroup()); - else - threadAssertTrue(g == egroup); - String name = current.getName(); - threadAssertTrue(name.endsWith("thread-1")); - } catch (SecurityException ok) { - // Also pass if not allowed to change setting - } + try { + Thread current = Thread.currentThread(); + threadAssertTrue(!current.isDaemon()); + threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY); + ThreadGroup g = current.getThreadGroup(); + SecurityManager s = System.getSecurityManager(); + if (s != null) + threadAssertTrue(g == s.getThreadGroup()); + else + threadAssertTrue(g == egroup); + String name = current.getName(); + threadAssertTrue(name.endsWith("thread-1")); + } catch (SecurityException ok) { + // Also pass if not allowed to change setting + } } }; ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory()); @@ -354,13 +280,11 @@ public class ExecutorsTest extends JSR166TestCase{ e.execute(r); try { e.shutdown(); - } catch(SecurityException ok) { + } catch (SecurityException ok) { } try { Thread.sleep(SHORT_DELAY_MS); - } catch (Exception eX) { - unexpectedException(); } finally { joinPool(e); } @@ -371,61 +295,60 @@ public class ExecutorsTest extends JSR166TestCase{ * specified group, priority, daemon status, name, * access control context and context class loader */ - public void testPrivilegedThreadFactory() { - Policy savedPolicy = null; - try { - savedPolicy = Policy.getPolicy(); - AdjustablePolicy policy = new AdjustablePolicy(); - policy.addPermission(new RuntimePermission("getContextClassLoader")); - policy.addPermission(new RuntimePermission("setContextClassLoader")); - Policy.setPolicy(policy); - } catch (AccessControlException ok) { - return; - } - final ThreadGroup egroup = Thread.currentThread().getThreadGroup(); - final ClassLoader thisccl = Thread.currentThread().getContextClassLoader(); - final AccessControlContext thisacc = AccessController.getContext(); - Runnable r = new Runnable() { - public void run() { - try { - Thread current = Thread.currentThread(); - threadAssertTrue(!current.isDaemon()); - threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY); - ThreadGroup g = current.getThreadGroup(); - SecurityManager s = System.getSecurityManager(); - if (s != null) - threadAssertTrue(g == s.getThreadGroup()); - else - threadAssertTrue(g == egroup); - String name = current.getName(); - threadAssertTrue(name.endsWith("thread-1")); - threadAssertTrue(thisccl == current.getContextClassLoader()); - threadAssertTrue(thisacc.equals(AccessController.getContext())); - } catch(SecurityException ok) { - // Also pass if not allowed to change settings - } - } - }; - ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory()); - - Policy.setPolicy(savedPolicy); - e.execute(r); - try { - e.shutdown(); - } catch(SecurityException ok) { - } - try { - Thread.sleep(SHORT_DELAY_MS); - } catch (Exception ex) { - unexpectedException(); - } finally { - joinPool(e); + public void testPrivilegedThreadFactory() throws Exception { + Runnable r = new CheckedRunnable() { + public void realRun() throws Exception { + final ThreadGroup egroup = Thread.currentThread().getThreadGroup(); + final ClassLoader thisccl = Thread.currentThread().getContextClassLoader(); + final AccessControlContext thisacc = AccessController.getContext(); + Runnable r = new CheckedRunnable() { + public void realRun() { + Thread current = Thread.currentThread(); + assertTrue(!current.isDaemon()); + assertTrue(current.getPriority() <= Thread.NORM_PRIORITY); + ThreadGroup g = current.getThreadGroup(); + SecurityManager s = System.getSecurityManager(); + if (s != null) + assertTrue(g == s.getThreadGroup()); + else + assertTrue(g == egroup); + String name = current.getName(); + assertTrue(name.endsWith("thread-1")); + assertTrue(thisccl == current.getContextClassLoader()); + assertTrue(thisacc.equals(AccessController.getContext())); + }}; + ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory()); + e.execute(r); + e.shutdown(); + Thread.sleep(SHORT_DELAY_MS); + joinPool(e); + }}; + + runWithPermissions(r, + new RuntimePermission("getClassLoader"), + new RuntimePermission("setContextClassLoader"), + new RuntimePermission("modifyThread")); + } + + boolean haveCCLPermissions() { + SecurityManager sm = System.getSecurityManager(); + if (sm != null) { + try { + sm.checkPermission(new RuntimePermission("setContextClassLoader")); + sm.checkPermission(new RuntimePermission("getClassLoader")); + } catch (AccessControlException e) { + return false; + } } - + return true; } void checkCCL() { - AccessController.getContext().checkPermission(new RuntimePermission("getContextClassLoader")); + SecurityManager sm = System.getSecurityManager(); + if (sm != null) { + sm.checkPermission(new RuntimePermission("setContextClassLoader")); + sm.checkPermission(new RuntimePermission("getClassLoader")); + } } class CheckCCL implements Callable<Object> { @@ -441,222 +364,192 @@ public class ExecutorsTest extends JSR166TestCase{ * privilegedCallableUsingCurrentClassLoader throws ACE */ public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() { - Policy savedPolicy = null; - try { - savedPolicy = Policy.getPolicy(); - AdjustablePolicy policy = new AdjustablePolicy(); - Policy.setPolicy(policy); - } catch (AccessControlException ok) { - return; - } - - // Check if program still has too many permissions to run test - try { - checkCCL(); - // too many privileges to test; so return - Policy.setPolicy(savedPolicy); - return; - } catch(AccessControlException ok) { - } + Runnable r = new CheckedRunnable() { + public void realRun() throws Exception { + if (System.getSecurityManager() == null) + return; + try { + Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable()); + shouldThrow(); + } catch (AccessControlException success) {} + }}; - try { - Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable()); - shouldThrow(); - } catch(AccessControlException success) { - } catch(Exception ex) { - unexpectedException(); - } - finally { - Policy.setPolicy(savedPolicy); - } + runWithoutPermissions(r); } /** * With class loader permissions, calling * privilegedCallableUsingCurrentClassLoader does not throw ACE */ - public void testprivilegedCallableUsingCCLWithPrivs() { - Policy savedPolicy = null; - try { - savedPolicy = Policy.getPolicy(); - AdjustablePolicy policy = new AdjustablePolicy(); - policy.addPermission(new RuntimePermission("getContextClassLoader")); - policy.addPermission(new RuntimePermission("setContextClassLoader")); - Policy.setPolicy(policy); - } catch (AccessControlException ok) { - return; - } + public void testprivilegedCallableUsingCCLWithPrivs() throws Exception { + Runnable r = new CheckedRunnable() { + public void realRun() throws Exception { + Executors.privilegedCallableUsingCurrentClassLoader + (new NoOpCallable()) + .call(); + }}; - try { - Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable()); - task.call(); - } catch(Exception ex) { - unexpectedException(); - } - finally { - Policy.setPolicy(savedPolicy); - } + runWithPermissions(r, + new RuntimePermission("getClassLoader"), + new RuntimePermission("setContextClassLoader")); } /** * Without permissions, calling privilegedCallable throws ACE */ - public void testprivilegedCallableWithNoPrivs() { - Callable task; - Policy savedPolicy = null; - AdjustablePolicy policy = null; - AccessControlContext noprivAcc = null; - try { - savedPolicy = Policy.getPolicy(); - policy = new AdjustablePolicy(); - Policy.setPolicy(policy); - noprivAcc = AccessController.getContext(); - task = Executors.privilegedCallable(new CheckCCL()); - Policy.setPolicy(savedPolicy); - } catch (AccessControlException ok) { - return; // program has too few permissions to set up test - } - - // Make sure that program doesn't have too many permissions - try { - AccessController.doPrivileged(new PrivilegedAction() { - public Object run() { - checkCCL(); - return null; - }}, noprivAcc); - // too many permssions; skip test - return; - } catch(AccessControlException ok) { - } - - try { - task.call(); - shouldThrow(); - } catch(AccessControlException success) { - } catch(Exception ex) { - unexpectedException(); - } + public void testprivilegedCallableWithNoPrivs() throws Exception { + Runnable r = new CheckedRunnable() { + public void realRun() throws Exception { + if (System.getSecurityManager() == null) + return; + Callable task = Executors.privilegedCallable(new CheckCCL()); + try { + task.call(); + shouldThrow(); + } catch (AccessControlException success) {} + }}; + + runWithoutPermissions(r); + + // It seems rather difficult to test that the + // AccessControlContext of the privilegedCallable is used + // instead of its caller. Below is a failed attempt to do + // that, which does not work because the AccessController + // cannot capture the internal state of the current Policy. + // It would be much more work to differentiate based on, + // e.g. CodeSource. + +// final AccessControlContext[] noprivAcc = new AccessControlContext[1]; +// final Callable[] task = new Callable[1]; + +// runWithPermissions +// (new CheckedRunnable() { +// public void realRun() { +// if (System.getSecurityManager() == null) +// return; +// noprivAcc[0] = AccessController.getContext(); +// task[0] = Executors.privilegedCallable(new CheckCCL()); +// try { +// AccessController.doPrivileged(new PrivilegedAction<Void>() { +// public Void run() { +// checkCCL(); +// return null; +// }}, noprivAcc[0]); +// shouldThrow(); +// } catch (AccessControlException success) {} +// }}); + +// runWithPermissions +// (new CheckedRunnable() { +// public void realRun() throws Exception { +// if (System.getSecurityManager() == null) +// return; +// // Verify that we have an underprivileged ACC +// try { +// AccessController.doPrivileged(new PrivilegedAction<Void>() { +// public Void run() { +// checkCCL(); +// return null; +// }}, noprivAcc[0]); +// shouldThrow(); +// } catch (AccessControlException success) {} + +// try { +// task[0].call(); +// shouldThrow(); +// } catch (AccessControlException success) {} +// }}, +// new RuntimePermission("getClassLoader"), +// new RuntimePermission("setContextClassLoader")); } /** * With permissions, calling privilegedCallable succeeds */ - public void testprivilegedCallableWithPrivs() { - Policy savedPolicy = null; - try { - savedPolicy = Policy.getPolicy(); - AdjustablePolicy policy = new AdjustablePolicy(); - policy.addPermission(new RuntimePermission("getContextClassLoader")); - policy.addPermission(new RuntimePermission("setContextClassLoader")); - Policy.setPolicy(policy); - } catch (AccessControlException ok) { - return; - } - - Callable task = Executors.privilegedCallable(new CheckCCL()); - try { - task.call(); - } catch(Exception ex) { - unexpectedException(); - } finally { - Policy.setPolicy(savedPolicy); - } + public void testprivilegedCallableWithPrivs() throws Exception { + Runnable r = new CheckedRunnable() { + public void realRun() throws Exception { + Executors.privilegedCallable(new CheckCCL()).call(); + }}; + + runWithPermissions(r, + new RuntimePermission("getClassLoader"), + new RuntimePermission("setContextClassLoader")); } /** * callable(Runnable) returns null when called - */ - public void testCallable1() { - try { - Callable c = Executors.callable(new NoOpRunnable()); - assertNull(c.call()); - } catch(Exception ex) { - unexpectedException(); - } - + */ + public void testCallable1() throws Exception { + Callable c = Executors.callable(new NoOpRunnable()); + assertNull(c.call()); } /** * callable(Runnable, result) returns result when called - */ - public void testCallable2() { - try { - Callable c = Executors.callable(new NoOpRunnable(), one); - assertEquals(one, c.call()); - } catch(Exception ex) { - unexpectedException(); - } + */ + public void testCallable2() throws Exception { + Callable c = Executors.callable(new NoOpRunnable(), one); + assertSame(one, c.call()); } /** * callable(PrivilegedAction) returns its result when called - */ - public void testCallable3() { - try { - Callable c = Executors.callable(new PrivilegedAction() { - public Object run() { return one; }}); - assertEquals(one, c.call()); - } catch(Exception ex) { - unexpectedException(); - } + */ + public void testCallable3() throws Exception { + Callable c = Executors.callable(new PrivilegedAction() { + public Object run() { return one; }}); + assertSame(one, c.call()); } /** * callable(PrivilegedExceptionAction) returns its result when called - */ - public void testCallable4() { - try { - Callable c = Executors.callable(new PrivilegedExceptionAction() { - public Object run() { return one; }}); - assertEquals(one, c.call()); - } catch(Exception ex) { - unexpectedException(); - } + */ + public void testCallable4() throws Exception { + Callable c = Executors.callable(new PrivilegedExceptionAction() { + public Object run() { return one; }}); + assertSame(one, c.call()); } /** * callable(null Runnable) throws NPE - */ + */ public void testCallableNPE1() { try { - Runnable r = null; - Callable c = Executors.callable(r); - } catch (NullPointerException success) { - } + Callable c = Executors.callable((Runnable) null); + shouldThrow(); + } catch (NullPointerException success) {} } /** * callable(null, result) throws NPE - */ + */ public void testCallableNPE2() { try { - Runnable r = null; - Callable c = Executors.callable(r, one); - } catch (NullPointerException success) { - } + Callable c = Executors.callable((Runnable) null, one); + shouldThrow(); + } catch (NullPointerException success) {} } /** * callable(null PrivilegedAction) throws NPE - */ + */ public void testCallableNPE3() { try { - PrivilegedAction r = null; - Callable c = Executors.callable(r); - } catch (NullPointerException success) { - } + Callable c = Executors.callable((PrivilegedAction) null); + shouldThrow(); + } catch (NullPointerException success) {} } /** * callable(null PrivilegedExceptionAction) throws NPE - */ + */ public void testCallableNPE4() { try { - PrivilegedExceptionAction r = null; - Callable c = Executors.callable(r); - } catch (NullPointerException success) { - } + Callable c = Executors.callable((PrivilegedExceptionAction) null); + shouldThrow(); + } catch (NullPointerException success) {} } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/FutureTaskTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/FutureTaskTest.java index 2635054..b1f9f40 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/FutureTaskTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/FutureTaskTest.java @@ -2,14 +2,15 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.util.*; public class FutureTaskTest extends JSR166TestCase { @@ -34,9 +35,7 @@ public class FutureTaskTest extends JSR166TestCase { try { FutureTask task = new FutureTask(null); shouldThrow(); - } - catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** @@ -46,16 +45,14 @@ public class FutureTaskTest extends JSR166TestCase { try { FutureTask task = new FutureTask(null, Boolean.TRUE); shouldThrow(); - } - catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * isDone is true when a task completes */ public void testIsDone() { - FutureTask task = new FutureTask( new NoOpCallable()); + FutureTask task = new FutureTask(new NoOpCallable()); task.run(); assertTrue(task.isDone()); assertFalse(task.isCancelled()); @@ -86,34 +83,24 @@ public class FutureTaskTest extends JSR166TestCase { /** * setting value causes get to return it */ - public void testSet() { + public void testSet() throws Exception { PublicFutureTask task = new PublicFutureTask(new NoOpCallable()); task.set(one); - try { - assertEquals(task.get(), one); - } - catch(Exception e) { - unexpectedException(); - } + assertSame(task.get(), one); } /** * setException causes get to throw ExecutionException */ - public void testSetException() { + public void testSetException() throws Exception { Exception nse = new NoSuchElementException(); PublicFutureTask task = new PublicFutureTask(new NoOpCallable()); task.setException(nse); try { Object x = task.get(); shouldThrow(); - } - catch(ExecutionException ee) { - Throwable cause = ee.getCause(); - assertEquals(cause, nse); - } - catch(Exception e) { - unexpectedException(); + } catch (ExecutionException success) { + assertSame(success.getCause(), nse); } } @@ -121,7 +108,7 @@ public class FutureTaskTest extends JSR166TestCase { * Cancelling before running succeeds */ public void testCancelBeforeRun() { - FutureTask task = new FutureTask( new NoOpCallable()); + FutureTask task = new FutureTask(new NoOpCallable()); assertTrue(task.cancel(false)); task.run(); assertTrue(task.isDone()); @@ -132,7 +119,7 @@ public class FutureTaskTest extends JSR166TestCase { * Cancel(true) before run succeeds */ public void testCancelBeforeRun2() { - FutureTask task = new FutureTask( new NoOpCallable()); + FutureTask task = new FutureTask(new NoOpCallable()); assertTrue(task.cancel(true)); task.run(); assertTrue(task.isDone()); @@ -143,7 +130,7 @@ public class FutureTaskTest extends JSR166TestCase { * cancel of a completed task fails */ public void testCancelAfterRun() { - FutureTask task = new FutureTask( new NoOpCallable()); + FutureTask task = new FutureTask(new NoOpCallable()); task.run(); assertFalse(task.cancel(false)); assertTrue(task.isDone()); @@ -153,320 +140,219 @@ public class FutureTaskTest extends JSR166TestCase { /** * cancel(true) interrupts a running task */ - public void testCancelInterrupt() { - FutureTask task = new FutureTask( new Callable() { - public Object call() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - threadShouldThrow(); - } - catch (InterruptedException success) {} + public void testCancelInterrupt() throws InterruptedException { + final FutureTask task = + new FutureTask(new CheckedInterruptedCallable<Object>() { + public Object realCall() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); return Boolean.TRUE; - } }); - Thread t = new Thread(task); + }}); + + Thread t = new Thread(task); t.start(); - - try { - Thread.sleep(SHORT_DELAY_MS); - assertTrue(task.cancel(true)); - t.join(); - assertTrue(task.isDone()); - assertTrue(task.isCancelled()); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + assertTrue(task.cancel(true)); + t.join(); + assertTrue(task.isDone()); + assertTrue(task.isCancelled()); } /** * cancel(false) does not interrupt a running task */ - public void testCancelNoInterrupt() { - FutureTask task = new FutureTask( new Callable() { - public Object call() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - } - catch (InterruptedException success) { - threadFail("should not interrupt"); - } + public void testCancelNoInterrupt() throws InterruptedException { + final FutureTask task = + new FutureTask(new CheckedCallable<Object>() { + public Object realCall() throws InterruptedException { + Thread.sleep(MEDIUM_DELAY_MS); return Boolean.TRUE; - } }); - Thread t = new Thread(task); + }}); + + Thread t = new Thread(task); t.start(); - - try { - Thread.sleep(SHORT_DELAY_MS); - assertTrue(task.cancel(false)); - t.join(); - assertTrue(task.isDone()); - assertTrue(task.isCancelled()); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + assertTrue(task.cancel(false)); + t.join(); + assertTrue(task.isDone()); + assertTrue(task.isCancelled()); } /** * set in one thread causes get in another thread to retrieve value */ - public void testGet1() { - final FutureTask ft = new FutureTask(new Callable() { - public Object call() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - } catch(InterruptedException e){ - threadUnexpectedException(); - } + public void testGet1() throws InterruptedException { + final FutureTask ft = + new FutureTask(new CheckedCallable<Object>() { + public Object realCall() throws InterruptedException { return Boolean.TRUE; - } - }); - Thread t = new Thread(new Runnable() { - public void run() { - try { - ft.get(); - } catch(Exception e){ - threadUnexpectedException(); - } - } - }); - try { - assertFalse(ft.isDone()); - assertFalse(ft.isCancelled()); - t.start(); - Thread.sleep(SHORT_DELAY_MS); - ft.run(); - t.join(); - assertTrue(ft.isDone()); - assertFalse(ft.isCancelled()); - } catch(InterruptedException e){ - unexpectedException(); - - } + }}); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws Exception { + assertSame(Boolean.TRUE, ft.get()); + }}); + + assertFalse(ft.isDone()); + assertFalse(ft.isCancelled()); + t.start(); + Thread.sleep(SHORT_DELAY_MS); + ft.run(); + t.join(); + assertTrue(ft.isDone()); + assertFalse(ft.isCancelled()); } /** * set in one thread causes timed get in another thread to retrieve value */ - public void testTimedGet1() { - final FutureTask ft = new FutureTask(new Callable() { - public Object call() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - } catch(InterruptedException e){ - threadUnexpectedException(); - } + public void testTimedGet1() throws InterruptedException { + final FutureTask ft = + new FutureTask(new CheckedCallable<Object>() { + public Object realCall() throws InterruptedException { return Boolean.TRUE; - } - }); - Thread t = new Thread(new Runnable() { - public void run() { - try { - ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - } catch(TimeoutException success) { - } catch(Exception e){ - threadUnexpectedException(); - } - } - }); - try { - assertFalse(ft.isDone()); - assertFalse(ft.isCancelled()); - t.start(); - ft.run(); - t.join(); - assertTrue(ft.isDone()); - assertFalse(ft.isCancelled()); - } catch(InterruptedException e){ - unexpectedException(); - - } + }}); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws Exception { + assertSame(Boolean.TRUE, ft.get(SMALL_DELAY_MS, MILLISECONDS)); + }}); + + assertFalse(ft.isDone()); + assertFalse(ft.isCancelled()); + t.start(); + Thread.sleep(SHORT_DELAY_MS); + ft.run(); + t.join(); + assertTrue(ft.isDone()); + assertFalse(ft.isCancelled()); } /** * Cancelling a task causes timed get in another thread to throw CancellationException */ - public void testTimedGet_Cancellation() { - final FutureTask ft = new FutureTask(new Callable() { - public Object call() { - try { - Thread.sleep(SMALL_DELAY_MS); - threadShouldThrow(); - } catch(InterruptedException e) { - } + public void testTimedGet_Cancellation() throws InterruptedException { + final FutureTask ft = + new FutureTask(new CheckedInterruptedCallable<Object>() { + public Object realCall() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); return Boolean.TRUE; - } - }); - try { - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(CancellationException success) {} - catch(Exception e){ - threadUnexpectedException(); - } - } - }); - Thread t2 = new Thread(ft); - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - ft.cancel(true); - t1.join(); - t2.join(); - } catch(InterruptedException ie){ - unexpectedException(); - } + }}); + + Thread t1 = new ThreadShouldThrow(CancellationException.class) { + public void realRun() throws Exception { + ft.get(MEDIUM_DELAY_MS, MILLISECONDS); + }}; + Thread t2 = new Thread(ft); + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + ft.cancel(true); + t1.join(); + t2.join(); } /** * Cancelling a task causes get in another thread to throw CancellationException */ - public void testGet_Cancellation() { - final FutureTask ft = new FutureTask(new Callable() { - public Object call() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - threadShouldThrow(); - } catch(InterruptedException e){ - } + public void testGet_Cancellation() throws InterruptedException { + final FutureTask ft = + new FutureTask(new CheckedInterruptedCallable<Object>() { + public Object realCall() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); return Boolean.TRUE; - } - }); - try { - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - ft.get(); - threadShouldThrow(); - } catch(CancellationException success){ - } - catch(Exception e){ - threadUnexpectedException(); - } - } - }); - Thread t2 = new Thread(ft); - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - ft.cancel(true); - t1.join(); - t2.join(); - } catch(InterruptedException success){ - unexpectedException(); - } + }}); + Thread t1 = new ThreadShouldThrow(CancellationException.class) { + public void realRun() throws Exception { + ft.get(); + }}; + + Thread t2 = new Thread(ft); + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + ft.cancel(true); + t1.join(); + t2.join(); } - + /** * A runtime exception in task causes get to throw ExecutionException */ - public void testGet_ExecutionException() { + public void testGet_ExecutionException() throws InterruptedException { final FutureTask ft = new FutureTask(new Callable() { - public Object call() { - int i = 5/0; - return Boolean.TRUE; - } - }); + public Object call() { + return 5/0; + }}); + + ft.run(); try { - ft.run(); ft.get(); shouldThrow(); - } catch(ExecutionException success){ - } - catch(Exception e){ - unexpectedException(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof ArithmeticException); } } - + /** * A runtime exception in task causes timed get to throw ExecutionException */ - public void testTimedGet_ExecutionException2() { + public void testTimedGet_ExecutionException2() throws Exception { final FutureTask ft = new FutureTask(new Callable() { - public Object call() { - int i = 5/0; - return Boolean.TRUE; - } - }); + public Object call() { + return 5/0; + }}); + + ft.run(); try { - ft.run(); - ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS); + ft.get(SHORT_DELAY_MS, MILLISECONDS); shouldThrow(); - } catch(ExecutionException success) { - } catch(TimeoutException success) { } // unlikely but OK - catch(Exception e){ - unexpectedException(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof ArithmeticException); } } - + /** * Interrupting a waiting get causes it to throw InterruptedException */ - public void testGet_InterruptedException() { + public void testGet_InterruptedException() throws InterruptedException { final FutureTask ft = new FutureTask(new NoOpCallable()); - Thread t = new Thread(new Runnable() { - public void run() { - try { - ft.get(); - threadShouldThrow(); - } catch(InterruptedException success){ - } catch(Exception e){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws Exception { + ft.get(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * Interrupting a waiting timed get causes it to throw InterruptedException */ - public void testTimedGet_InterruptedException2() { + public void testTimedGet_InterruptedException2() throws InterruptedException { final FutureTask ft = new FutureTask(new NoOpCallable()); - Thread t = new Thread(new Runnable() { - public void run() { - try { - ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(InterruptedException success){} - catch(Exception e){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws Exception { + ft.get(LONG_DELAY_MS,MILLISECONDS); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } - + /** * A timed out timed get throws TimeoutException */ - public void testGet_TimeoutException() { + public void testGet_TimeoutException() throws Exception { try { FutureTask ft = new FutureTask(new NoOpCallable()); - ft.get(1,TimeUnit.MILLISECONDS); + ft.get(1,MILLISECONDS); shouldThrow(); - } catch(TimeoutException success){} - catch(Exception success){ - unexpectedException(); - } + } catch (TimeoutException success) {} } - + } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/JSR166TestCase.java b/concurrent/src/test/java/tests/api/java/util/concurrent/JSR166TestCase.java index 6acd363..b764855 100644 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/JSR166TestCase.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/JSR166TestCase.java @@ -6,11 +6,12 @@ * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.io.*; import java.security.*; @@ -88,71 +89,91 @@ import java.security.*; * </ul> */ public class JSR166TestCase extends TestCase { - /** - * Runs all JSR166 unit tests using junit.textui.TestRunner - */ - public static void main (String[] args) { - int iters = 1; - if (args.length > 0) - iters = Integer.parseInt(args[0]); - Test s = suite(); - for (int i = 0; i < iters; ++i) { - // junit.textui.TestRunner.run (s); android-changed - System.gc(); - System.runFinalization(); - } - System.exit(0); - } + private static final boolean useSecurityManager = + Boolean.getBoolean("jsr166.useSecurityManager"); + + // BEGIN android-removed + // /** + // * Runs all JSR166 unit tests using junit.textui.TestRunner + // */ + // public static void main(String[] args) { + // if (useSecurityManager) { + // System.err.println("Setting a permissive security manager"); + // Policy.setPolicy(permissivePolicy()); + // System.setSecurityManager(new SecurityManager()); + // } + // int iters = 1; + // if (args.length > 0) + // iters = Integer.parseInt(args[0]); + // Test s = suite(); + // for (int i = 0; i < iters; ++i) { + // junit.textui.TestRunner.run(s); + // System.gc(); + // System.runFinalization(); + // } + // System.exit(0); + // } + // END android-removed /** * Collects all JSR166 unit tests as one suite */ - public static Test suite ( ) { - // BEGIN android-changed + public static Test suite() { TestSuite suite = new TestSuite("JSR166 Unit Tests"); - suite.addTest(AbstractExecutorServiceTest.suite()); - suite.addTest(AbstractQueueTest.suite()); - suite.addTest(AbstractQueuedSynchronizerTest.suite()); - suite.addTest(ArrayBlockingQueueTest.suite()); - suite.addTest(AtomicBooleanTest.suite()); - suite.addTest(AtomicIntegerArrayTest.suite()); - suite.addTest(AtomicIntegerFieldUpdaterTest.suite()); - suite.addTest(AtomicIntegerTest.suite()); - suite.addTest(AtomicLongArrayTest.suite()); - suite.addTest(AtomicLongFieldUpdaterTest.suite()); - suite.addTest(AtomicLongTest.suite()); - suite.addTest(AtomicMarkableReferenceTest.suite()); - suite.addTest(AtomicReferenceArrayTest.suite()); - suite.addTest(AtomicReferenceFieldUpdaterTest.suite()); - suite.addTest(AtomicReferenceTest.suite()); - suite.addTest(AtomicStampedReferenceTest.suite()); - suite.addTest(ConcurrentHashMapTest.suite()); - suite.addTest(ConcurrentLinkedQueueTest.suite()); - suite.addTest(CopyOnWriteArrayListTest.suite()); - suite.addTest(CopyOnWriteArraySetTest.suite()); - suite.addTest(CountDownLatchTest.suite()); - suite.addTest(CyclicBarrierTest.suite()); - suite.addTest(DelayQueueTest.suite()); - suite.addTest(ExchangerTest.suite()); - suite.addTest(ExecutorsTest.suite()); - suite.addTest(ExecutorCompletionServiceTest.suite()); - suite.addTest(FutureTaskTest.suite()); - suite.addTest(LinkedBlockingQueueTest.suite()); - suite.addTest(LinkedListTest.suite()); - suite.addTest(LockSupportTest.suite()); - suite.addTest(PriorityBlockingQueueTest.suite()); - suite.addTest(PriorityQueueTest.suite()); - suite.addTest(ReentrantLockTest.suite()); - suite.addTest(ReentrantReadWriteLockTest.suite()); - suite.addTest(ScheduledExecutorTest.suite()); - suite.addTest(SemaphoreTest.suite()); - suite.addTest(SynchronousQueueTest.suite()); - suite.addTest(SystemTest.suite()); - suite.addTest(ThreadLocalTest.suite()); - suite.addTest(ThreadPoolExecutorTest.suite()); - suite.addTest(ThreadTest.suite()); - suite.addTest(TimeUnitTest.suite()); - // END android-changed + + suite.addTest(new TestSuite(AbstractExecutorServiceTest.class)); + suite.addTest(new TestSuite(AbstractQueueTest.class)); + suite.addTest(new TestSuite(AbstractQueuedSynchronizerTest.class)); + suite.addTest(new TestSuite(AbstractQueuedLongSynchronizerTest.class)); + suite.addTest(new TestSuite(ArrayBlockingQueueTest.class)); + suite.addTest(new TestSuite(ArrayDequeTest.class)); + suite.addTest(new TestSuite(AtomicBooleanTest.class)); + suite.addTest(new TestSuite(AtomicIntegerArrayTest.class)); + suite.addTest(new TestSuite(AtomicIntegerFieldUpdaterTest.class)); + suite.addTest(new TestSuite(AtomicIntegerTest.class)); + suite.addTest(new TestSuite(AtomicLongArrayTest.class)); + suite.addTest(new TestSuite(AtomicLongFieldUpdaterTest.class)); + suite.addTest(new TestSuite(AtomicLongTest.class)); + suite.addTest(new TestSuite(AtomicMarkableReferenceTest.class)); + suite.addTest(new TestSuite(AtomicReferenceArrayTest.class)); + suite.addTest(new TestSuite(AtomicReferenceFieldUpdaterTest.class)); + suite.addTest(new TestSuite(AtomicReferenceTest.class)); + suite.addTest(new TestSuite(AtomicStampedReferenceTest.class)); + suite.addTest(new TestSuite(ConcurrentHashMapTest.class)); + suite.addTest(new TestSuite(ConcurrentLinkedQueueTest.class)); + suite.addTest(new TestSuite(ConcurrentSkipListMapTest.class)); + suite.addTest(new TestSuite(ConcurrentSkipListSubMapTest.class)); + suite.addTest(new TestSuite(ConcurrentSkipListSetTest.class)); + suite.addTest(new TestSuite(ConcurrentSkipListSubSetTest.class)); + suite.addTest(new TestSuite(CopyOnWriteArrayListTest.class)); + suite.addTest(new TestSuite(CopyOnWriteArraySetTest.class)); + suite.addTest(new TestSuite(CountDownLatchTest.class)); + suite.addTest(new TestSuite(CyclicBarrierTest.class)); + suite.addTest(new TestSuite(DelayQueueTest.class)); + suite.addTest(new TestSuite(EntryTest.class)); + suite.addTest(new TestSuite(ExchangerTest.class)); + suite.addTest(new TestSuite(ExecutorsTest.class)); + suite.addTest(new TestSuite(ExecutorCompletionServiceTest.class)); + suite.addTest(new TestSuite(FutureTaskTest.class)); + suite.addTest(new TestSuite(LinkedBlockingDequeTest.class)); + suite.addTest(new TestSuite(LinkedBlockingQueueTest.class)); + suite.addTest(new TestSuite(LinkedListTest.class)); + suite.addTest(new TestSuite(LockSupportTest.class)); + suite.addTest(new TestSuite(PriorityBlockingQueueTest.class)); + suite.addTest(new TestSuite(PriorityQueueTest.class)); + suite.addTest(new TestSuite(ReentrantLockTest.class)); + suite.addTest(new TestSuite(ReentrantReadWriteLockTest.class)); + suite.addTest(new TestSuite(ScheduledExecutorTest.class)); + suite.addTest(new TestSuite(ScheduledExecutorSubclassTest.class)); + suite.addTest(new TestSuite(SemaphoreTest.class)); + suite.addTest(new TestSuite(SynchronousQueueTest.class)); + suite.addTest(new TestSuite(SystemTest.class)); + suite.addTest(new TestSuite(ThreadLocalTest.class)); + suite.addTest(new TestSuite(ThreadPoolExecutorTest.class)); + suite.addTest(new TestSuite(ThreadPoolExecutorSubclassTest.class)); + suite.addTest(new TestSuite(ThreadTest.class)); + suite.addTest(new TestSuite(TimeUnitTest.class)); + return suite; } @@ -178,7 +199,7 @@ public class JSR166TestCase extends TestCase { /** * Sets delays as multiples of SHORT_DELAY. */ - protected void setDelays() { + protected void setDelays() { SHORT_DELAY_MS = getShortDelay(); SMALL_DELAY_MS = SHORT_DELAY_MS * 5; MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10; @@ -272,13 +293,16 @@ public class JSR166TestCase extends TestCase { * threadFail with message "should throw exception" */ public void threadShouldThrow() { - try { - threadFailed = true; - fail("should throw exception"); - } catch (AssertionFailedError e) { - e.printStackTrace(); - throw e; - } + threadFailed = true; + fail("should throw exception"); + } + + /** + * threadFail with message "should throw" + exceptionName + */ + public void threadShouldThrow(String exceptionName) { + threadFailed = true; + fail("should throw " + exceptionName); } /** @@ -304,11 +328,11 @@ public class JSR166TestCase extends TestCase { public void joinPool(ExecutorService exec) { try { exec.shutdown(); - assertTrue(exec.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch(SecurityException ok) { + assertTrue(exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + } catch (SecurityException ok) { // Allowed in case test doesn't have privs - } catch(InterruptedException ie) { - fail("Unexpected exception"); + } catch (InterruptedException ie) { + fail("Unexpected InterruptedException"); } } @@ -321,46 +345,105 @@ public class JSR166TestCase extends TestCase { } /** + * fail with message "should throw " + exceptionName + */ + public void shouldThrow(String exceptionName) { + fail("Should throw " + exceptionName); + } + + /** * fail with message "Unexpected exception" */ public void unexpectedException() { fail("Unexpected exception"); } + /** + * fail with message "Unexpected exception", with argument + */ + public void unexpectedException(Throwable ex) { + ex.printStackTrace(); + fail("Unexpected exception: " + ex); + } + /** * The number of elements to place in collections, arrays, etc. */ - static final int SIZE = 20; + public static final int SIZE = 20; // Some convenient Integer constants - static final Integer zero = new Integer(0); - static final Integer one = new Integer(1); - static final Integer two = new Integer(2); - static final Integer three = new Integer(3); - static final Integer four = new Integer(4); - static final Integer five = new Integer(5); - static final Integer six = new Integer(6); - static final Integer seven = new Integer(7); - static final Integer eight = new Integer(8); - static final Integer nine = new Integer(9); - static final Integer m1 = new Integer(-1); - static final Integer m2 = new Integer(-2); - static final Integer m3 = new Integer(-3); - static final Integer m4 = new Integer(-4); - static final Integer m5 = new Integer(-5); - static final Integer m6 = new Integer(-6); - static final Integer m10 = new Integer(-10); + public static final Integer zero = new Integer(0); + public static final Integer one = new Integer(1); + public static final Integer two = new Integer(2); + public static final Integer three = new Integer(3); + public static final Integer four = new Integer(4); + public static final Integer five = new Integer(5); + public static final Integer six = new Integer(6); + public static final Integer seven = new Integer(7); + public static final Integer eight = new Integer(8); + public static final Integer nine = new Integer(9); + public static final Integer m1 = new Integer(-1); + public static final Integer m2 = new Integer(-2); + public static final Integer m3 = new Integer(-3); + public static final Integer m4 = new Integer(-4); + public static final Integer m5 = new Integer(-5); + public static final Integer m6 = new Integer(-6); + public static final Integer m10 = new Integer(-10); + + + /** + * Runs Runnable r with a security policy that permits precisely + * the specified permissions. If there is no current security + * manager, the runnable is run twice, both with and without a + * security manager. We require that any security manager permit + * getPolicy/setPolicy. + */ + public void runWithPermissions(Runnable r, Permission... permissions) { + SecurityManager sm = System.getSecurityManager(); + if (sm == null) { + r.run(); + Policy savedPolicy = Policy.getPolicy(); + try { + Policy.setPolicy(permissivePolicy()); + System.setSecurityManager(new SecurityManager()); + runWithPermissions(r, permissions); + } finally { + System.setSecurityManager(null); + Policy.setPolicy(savedPolicy); + } + } else { + Policy savedPolicy = Policy.getPolicy(); + AdjustablePolicy policy = new AdjustablePolicy(permissions); + Policy.setPolicy(policy); + try { + r.run(); + } finally { + policy.addPermission(new SecurityPermission("setPolicy")); + Policy.setPolicy(savedPolicy); + } + } + } + + /** + * Runs a runnable without any permissions. + */ + public void runWithoutPermissions(Runnable r) { + runWithPermissions(r); + } /** * A security policy where new permissions can be dynamically added * or all cleared. */ - static class AdjustablePolicy extends java.security.Policy { + public static class AdjustablePolicy extends java.security.Policy { Permissions perms = new Permissions(); - AdjustablePolicy() { } + AdjustablePolicy(Permission... permissions) { + for (Permission permission : permissions) + perms.add(permission); + } void addPermission(Permission perm) { perms.add(perm); } void clearPermissions() { perms = new Permissions(); } public PermissionCollection getPermissions(CodeSource cs) { @@ -375,197 +458,293 @@ public class JSR166TestCase extends TestCase { public void refresh() {} } + /** + * Returns a policy containing all the permissions we ever need. + */ + public static Policy permissivePolicy() { + return new AdjustablePolicy + // Permissions j.u.c. needs directly + (new RuntimePermission("modifyThread"), + new RuntimePermission("getClassLoader"), + new RuntimePermission("setContextClassLoader"), + // Permissions needed to change permissions! + new SecurityPermission("getPolicy"), + new SecurityPermission("setPolicy"), + new RuntimePermission("setSecurityManager"), + // Permissions needed by the junit test harness + new RuntimePermission("accessDeclaredMembers"), + new PropertyPermission("*", "read"), + new java.io.FilePermission("<<ALL FILES>>", "read")); + } - // Some convenient Runnable classes - - static class NoOpRunnable implements Runnable { - public void run() {} + /** + * Sleep until the timeout has elapsed, or interrupted. + * Does <em>NOT</em> throw InterruptedException. + */ + void sleepTillInterrupted(long timeoutMillis) { + try { + Thread.sleep(timeoutMillis); + } catch (InterruptedException wakeup) {} } - static class NoOpCallable implements Callable { - public Object call() { return Boolean.TRUE; } + /** + * Returns a new started Thread running the given runnable. + */ + Thread newStartedThread(Runnable runnable) { + Thread t = new Thread(runnable); + t.start(); + return t; } - static final String TEST_STRING = "a test string"; + // Some convenient Runnable classes - static class StringTask implements Callable<String> { - public String call() { return TEST_STRING; } - } + public abstract class CheckedRunnable implements Runnable { + protected abstract void realRun() throws Throwable; - static class NPETask implements Callable<String> { - public String call() { throw new NullPointerException(); } + public final void run() { + try { + realRun(); + } catch (Throwable t) { + threadUnexpectedException(t); + } + } } - static class CallableOne implements Callable<Integer> { - public Integer call() { return one; } - } + public abstract class RunnableShouldThrow implements Runnable { + protected abstract void realRun() throws Throwable; - class ShortRunnable implements Runnable { - public void run() { + final Class<?> exceptionClass; + + <T extends Throwable> RunnableShouldThrow(Class<T> exceptionClass) { + this.exceptionClass = exceptionClass; + } + + public final void run() { try { - Thread.sleep(SHORT_DELAY_MS); - } - catch(Exception e) { - threadUnexpectedException(e); + realRun(); + threadShouldThrow(exceptionClass.getSimpleName()); + } catch (Throwable t) { + if (! exceptionClass.isInstance(t)) + threadUnexpectedException(t); } } } - class ShortInterruptedRunnable implements Runnable { - public void run() { + public abstract class ThreadShouldThrow extends Thread { + protected abstract void realRun() throws Throwable; + + final Class<?> exceptionClass; + + <T extends Throwable> ThreadShouldThrow(Class<T> exceptionClass) { + this.exceptionClass = exceptionClass; + } + + public final void run() { try { - Thread.sleep(SHORT_DELAY_MS); - threadShouldThrow(); - } - catch(InterruptedException success) { + realRun(); + threadShouldThrow(exceptionClass.getSimpleName()); + } catch (Throwable t) { + if (! exceptionClass.isInstance(t)) + threadUnexpectedException(t); } } } - class SmallRunnable implements Runnable { - public void run() { + public abstract class CheckedInterruptedRunnable implements Runnable { + protected abstract void realRun() throws Throwable; + + public final void run() { try { - Thread.sleep(SMALL_DELAY_MS); - } - catch(Exception e) { - threadUnexpectedException(e); + realRun(); + threadShouldThrow("InterruptedException"); + } catch (InterruptedException success) { + } catch (Throwable t) { + threadUnexpectedException(t); } } } - class SmallPossiblyInterruptedRunnable implements Runnable { - public void run() { + public abstract class CheckedCallable<T> implements Callable<T> { + protected abstract T realCall() throws Throwable; + + public final T call() { try { - Thread.sleep(SMALL_DELAY_MS); - } - catch(Exception e) { + return realCall(); + } catch (Throwable t) { + threadUnexpectedException(t); } + return null; } } - class SmallCallable implements Callable { - public Object call() { + public abstract class CheckedInterruptedCallable<T> implements Callable<T> { + protected abstract T realCall() throws Throwable; + + public final T call() { try { - Thread.sleep(SMALL_DELAY_MS); - } - catch(Exception e) { - threadUnexpectedException(e); + T result = realCall(); + threadShouldThrow("InterruptedException"); + return result; + } catch (InterruptedException success) { + } catch (Throwable t) { + threadUnexpectedException(t); } - return Boolean.TRUE; + return null; } } - class SmallInterruptedRunnable implements Runnable { - public void run() { + public static class NoOpRunnable implements Runnable { + public void run() {} + } + + public static class NoOpCallable implements Callable { + public Object call() { return Boolean.TRUE; } + } + + public static final String TEST_STRING = "a test string"; + + public static class StringTask implements Callable<String> { + public String call() { return TEST_STRING; } + } + + public Callable<String> latchAwaitingStringTask(final CountDownLatch latch) { + return new CheckedCallable<String>() { + public String realCall() { + try { + latch.await(); + } catch (InterruptedException quittingTime) {} + return TEST_STRING; + }}; + } + + public static class NPETask implements Callable<String> { + public String call() { throw new NullPointerException(); } + } + + public static class CallableOne implements Callable<Integer> { + public Integer call() { return one; } + } + + public class ShortRunnable extends CheckedRunnable { + protected void realRun() throws Throwable { + Thread.sleep(SHORT_DELAY_MS); + } + } + + public class ShortInterruptedRunnable extends CheckedInterruptedRunnable { + protected void realRun() throws InterruptedException { + Thread.sleep(SHORT_DELAY_MS); + } + } + + public class SmallRunnable extends CheckedRunnable { + protected void realRun() throws Throwable { + Thread.sleep(SMALL_DELAY_MS); + } + } + + public class SmallPossiblyInterruptedRunnable extends CheckedRunnable { + protected void realRun() { try { Thread.sleep(SMALL_DELAY_MS); - threadShouldThrow(); - } - catch(InterruptedException success) { - } + } catch (InterruptedException ok) {} } } + public class SmallCallable extends CheckedCallable { + protected Object realCall() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); + return Boolean.TRUE; + } + } - class MediumRunnable implements Runnable { - public void run() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - } - catch(Exception e) { - threadUnexpectedException(e); - } + public class SmallInterruptedRunnable extends CheckedInterruptedRunnable { + protected void realRun() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); } } - class MediumInterruptedRunnable implements Runnable { - public void run() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - threadShouldThrow(); - } - catch(InterruptedException success) { - } + public class MediumRunnable extends CheckedRunnable { + protected void realRun() throws Throwable { + Thread.sleep(MEDIUM_DELAY_MS); } } - class MediumPossiblyInterruptedRunnable implements Runnable { - public void run() { + public class MediumInterruptedRunnable extends CheckedInterruptedRunnable { + protected void realRun() throws InterruptedException { + Thread.sleep(MEDIUM_DELAY_MS); + } + } + + public class MediumPossiblyInterruptedRunnable extends CheckedRunnable { + protected void realRun() { try { Thread.sleep(MEDIUM_DELAY_MS); - } - catch(InterruptedException success) { - } + } catch (InterruptedException ok) {} } } - class LongPossiblyInterruptedRunnable implements Runnable { - public void run() { + public class LongPossiblyInterruptedRunnable extends CheckedRunnable { + protected void realRun() { try { Thread.sleep(LONG_DELAY_MS); - } - catch(InterruptedException success) { - } + } catch (InterruptedException ok) {} } } /** * For use as ThreadFactory in constructors */ - static class SimpleThreadFactory implements ThreadFactory{ - public Thread newThread(Runnable r){ + public static class SimpleThreadFactory implements ThreadFactory { + public Thread newThread(Runnable r) { return new Thread(r); } } - static class TrackedShortRunnable implements Runnable { - volatile boolean done = false; + public static class TrackedShortRunnable implements Runnable { + public volatile boolean done = false; public void run() { try { Thread.sleep(SMALL_DELAY_MS); done = true; - } catch(Exception e){ - } + } catch (InterruptedException ok) {} } } - static class TrackedMediumRunnable implements Runnable { - volatile boolean done = false; + public static class TrackedMediumRunnable implements Runnable { + public volatile boolean done = false; public void run() { try { Thread.sleep(MEDIUM_DELAY_MS); done = true; - } catch(Exception e){ - } + } catch (InterruptedException ok) {} } } - static class TrackedLongRunnable implements Runnable { - volatile boolean done = false; + public static class TrackedLongRunnable implements Runnable { + public volatile boolean done = false; public void run() { try { Thread.sleep(LONG_DELAY_MS); done = true; - } catch(Exception e){ - } + } catch (InterruptedException ok) {} } } - static class TrackedNoOpRunnable implements Runnable { - volatile boolean done = false; + public static class TrackedNoOpRunnable implements Runnable { + public volatile boolean done = false; public void run() { done = true; } } - static class TrackedCallable implements Callable { - volatile boolean done = false; + public static class TrackedCallable implements Callable { + public volatile boolean done = false; public Object call() { try { Thread.sleep(SMALL_DELAY_MS); done = true; - } catch(Exception e){ - } + } catch (InterruptedException ok) {} return Boolean.TRUE; } } @@ -574,9 +753,9 @@ public class JSR166TestCase extends TestCase { /** * For use as RejectedExecutionHandler in constructors */ - static class NoOpREHandler implements RejectedExecutionHandler{ - public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){} + public static class NoOpREHandler implements RejectedExecutionHandler { + public void rejectedExecution(Runnable r, + ThreadPoolExecutor executor) {} } - } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/LinkedBlockingDequeTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/LinkedBlockingDequeTest.java new file mode 100644 index 0000000..a858bb9 --- /dev/null +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/LinkedBlockingDequeTest.java @@ -0,0 +1,1671 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + */ + +package tests.api.java.util.concurrent; // android-added + +import junit.framework.*; +import java.util.*; +import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; +import java.io.*; + +public class LinkedBlockingDequeTest extends JSR166TestCase { + public static Test suite() { + return new TestSuite(LinkedBlockingDequeTest.class); + } + + /** + * Create a deque of given size containing consecutive + * Integers 0 ... n. + */ + private LinkedBlockingDeque populatedDeque(int n) { + LinkedBlockingDeque q = new LinkedBlockingDeque(n); + assertTrue(q.isEmpty()); + for (int i = 0; i < n; i++) + assertTrue(q.offer(new Integer(i))); + assertFalse(q.isEmpty()); + assertEquals(0, q.remainingCapacity()); + assertEquals(n, q.size()); + return q; + } + + /** + * isEmpty is true before add, false after + */ + public void testEmpty() { + LinkedBlockingDeque q = new LinkedBlockingDeque(); + assertTrue(q.isEmpty()); + q.add(new Integer(1)); + assertFalse(q.isEmpty()); + q.add(new Integer(2)); + q.removeFirst(); + q.removeFirst(); + assertTrue(q.isEmpty()); + } + + /** + * size changes when elements added and removed + */ + public void testSize() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(SIZE-i, q.size()); + q.removeFirst(); + } + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.size()); + q.add(new Integer(i)); + } + } + + /** + * offer(null) throws NPE + */ + public void testOfferFirstNull() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(); + q.offerFirst(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * OfferFirst succeeds + */ + public void testOfferFirst() { + LinkedBlockingDeque q = new LinkedBlockingDeque(); + assertTrue(q.offerFirst(new Integer(0))); + assertTrue(q.offerFirst(new Integer(1))); + } + + /** + * OfferLast succeeds + */ + public void testOfferLast() { + LinkedBlockingDeque q = new LinkedBlockingDeque(); + assertTrue(q.offerLast(new Integer(0))); + assertTrue(q.offerLast(new Integer(1))); + } + + /** + * pollFirst succeeds unless empty + */ + public void testPollFirst() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.pollFirst()); + } + assertNull(q.pollFirst()); + } + + /** + * pollLast succeeds unless empty + */ + public void testPollLast() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = SIZE-1; i >= 0; --i) { + assertEquals(i, q.pollLast()); + } + assertNull(q.pollLast()); + } + + /** + * peekFirst returns next element, or null if empty + */ + public void testPeekFirst() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.peekFirst()); + assertEquals(i, q.pollFirst()); + assertTrue(q.peekFirst() == null || + !q.peekFirst().equals(i)); + } + assertNull(q.peekFirst()); + } + + /** + * peek returns next element, or null if empty + */ + public void testPeek() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.peek()); + assertEquals(i, q.pollFirst()); + assertTrue(q.peek() == null || + !q.peek().equals(i)); + } + assertNull(q.peek()); + } + + /** + * peekLast returns next element, or null if empty + */ + public void testPeekLast() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = SIZE-1; i >= 0; --i) { + assertEquals(i, q.peekLast()); + assertEquals(i, q.pollLast()); + assertTrue(q.peekLast() == null || + !q.peekLast().equals(i)); + } + assertNull(q.peekLast()); + } + + /** + * getFirst returns next getFirst, or throws NSEE if empty + */ + public void testFirstElement() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.getFirst()); + assertEquals(i, q.pollFirst()); + } + try { + q.getFirst(); + shouldThrow(); + } catch (NoSuchElementException success) {} + assertNull(q.peekFirst()); + } + + /** + * getLast returns next element, or throws NSEE if empty + */ + public void testLastElement() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = SIZE-1; i >= 0; --i) { + assertEquals(i, q.getLast()); + assertEquals(i, q.pollLast()); + } + try { + q.getLast(); + shouldThrow(); + } catch (NoSuchElementException success) {} + assertNull(q.peekLast()); + } + + /** + * removeFirst removes next element, or throws NSEE if empty + */ + public void testRemoveFirst() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.removeFirst()); + } + try { + q.removeFirst(); + shouldThrow(); + } catch (NoSuchElementException success) {} + assertNull(q.peekFirst()); + } + + /** + * removeLast removes last element, or throws NSEE if empty + */ + public void testRemoveLast() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = SIZE - 1; i >= 0; --i) { + assertEquals(i, q.removeLast()); + } + try { + q.removeLast(); + shouldThrow(); + } catch (NoSuchElementException success) {} + assertNull(q.peekLast()); + } + + /** + * remove removes next element, or throws NSEE if empty + */ + public void testRemove() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.remove()); + } + try { + q.remove(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } + + /** + * removeFirstOccurrence(x) removes x and returns true if present + */ + public void testRemoveFirstOccurrence() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 1; i < SIZE; i+=2) { + assertTrue(q.removeFirstOccurrence(new Integer(i))); + } + for (int i = 0; i < SIZE; i+=2) { + assertTrue(q.removeFirstOccurrence(new Integer(i))); + assertFalse(q.removeFirstOccurrence(new Integer(i+1))); + } + assertTrue(q.isEmpty()); + } + + /** + * removeLastOccurrence(x) removes x and returns true if present + */ + public void testRemoveLastOccurrence() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 1; i < SIZE; i+=2) { + assertTrue(q.removeLastOccurrence(new Integer(i))); + } + for (int i = 0; i < SIZE; i+=2) { + assertTrue(q.removeLastOccurrence(new Integer(i))); + assertFalse(q.removeLastOccurrence(new Integer(i+1))); + } + assertTrue(q.isEmpty()); + } + + /** + * peekFirst returns element inserted with addFirst + */ + public void testAddFirst() { + LinkedBlockingDeque q = populatedDeque(3); + q.pollLast(); + q.addFirst(four); + assertSame(four, q.peekFirst()); + } + + /** + * peekLast returns element inserted with addLast + */ + public void testAddLast() { + LinkedBlockingDeque q = populatedDeque(3); + q.pollLast(); + q.addLast(four); + assertSame(four, q.peekLast()); + } + + + /** + * A new deque has the indicated capacity, or Integer.MAX_VALUE if + * none given + */ + public void testConstructor1() { + assertEquals(SIZE, new LinkedBlockingDeque(SIZE).remainingCapacity()); + assertEquals(Integer.MAX_VALUE, new LinkedBlockingDeque().remainingCapacity()); + } + + /** + * Constructor throws IAE if capacity argument nonpositive + */ + public void testConstructor2() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(0); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Initializing from null Collection throws NPE + */ + public void testConstructor3() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Initializing from Collection of null elements throws NPE + */ + public void testConstructor4() { + try { + Integer[] ints = new Integer[SIZE]; + LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Initializing from Collection with some null elements throws NPE + */ + public void testConstructor5() { + try { + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE-1; ++i) + ints[i] = new Integer(i); + LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Deque contains all elements of collection used to initialize + */ + public void testConstructor6() { + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints)); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); + } + + /** + * Deque transitions from empty to full when elements added + */ + public void testEmptyFull() { + LinkedBlockingDeque q = new LinkedBlockingDeque(2); + assertTrue(q.isEmpty()); + assertEquals("should have room for 2", 2, q.remainingCapacity()); + q.add(one); + assertFalse(q.isEmpty()); + q.add(two); + assertFalse(q.isEmpty()); + assertEquals(0, q.remainingCapacity()); + assertFalse(q.offer(three)); + } + + /** + * remainingCapacity decreases on add, increases on remove + */ + public void testRemainingCapacity() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.remainingCapacity()); + assertEquals(SIZE-i, q.size()); + q.remove(); + } + for (int i = 0; i < SIZE; ++i) { + assertEquals(SIZE-i, q.remainingCapacity()); + assertEquals(i, q.size()); + q.add(new Integer(i)); + } + } + + /** + * offer(null) throws NPE + */ + public void testOfferNull() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(1); + q.offer(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * add(null) throws NPE + */ + public void testAddNull() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(1); + q.add(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * push(null) throws NPE + */ + public void testPushNull() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(1); + q.push(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * push succeeds if not full; throws ISE if full + */ + public void testPush() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + Integer I = new Integer(i); + q.push(I); + assertEquals(I, q.peek()); + } + assertEquals(0, q.remainingCapacity()); + q.push(new Integer(SIZE)); + shouldThrow(); + } catch (IllegalStateException success) {} + } + + /** + * peekFirst returns element inserted with push + */ + public void testPushWithPeek() { + LinkedBlockingDeque q = populatedDeque(3); + q.pollLast(); + q.push(four); + assertSame(four, q.peekFirst()); + } + + + /** + * pop removes next element, or throws NSEE if empty + */ + public void testPop() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.pop()); + } + try { + q.pop(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } + + + /** + * Offer succeeds if not full; fails if full + */ + public void testOffer() { + LinkedBlockingDeque q = new LinkedBlockingDeque(1); + assertTrue(q.offer(zero)); + assertFalse(q.offer(one)); + } + + /** + * add succeeds if not full; throws ISE if full + */ + public void testAdd() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertTrue(q.add(new Integer(i))); + } + assertEquals(0, q.remainingCapacity()); + q.add(new Integer(SIZE)); + shouldThrow(); + } catch (IllegalStateException success) {} + } + + /** + * addAll(null) throws NPE + */ + public void testAddAll1() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(1); + q.addAll(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * addAll(this) throws IAE + */ + public void testAddAllSelf() { + try { + LinkedBlockingDeque q = populatedDeque(SIZE); + q.addAll(q); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * addAll of a collection with null elements throws NPE + */ + public void testAddAll2() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + Integer[] ints = new Integer[SIZE]; + q.addAll(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + /** + * addAll of a collection with any null elements throws NPE after + * possibly adding some elements + */ + public void testAddAll3() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE-1; ++i) + ints[i] = new Integer(i); + q.addAll(Arrays.asList(ints)); + shouldThrow(); + } catch (NullPointerException success) {} + } + /** + * addAll throws ISE if not enough room + */ + public void testAddAll4() { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(1); + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + q.addAll(Arrays.asList(ints)); + shouldThrow(); + } catch (IllegalStateException success) {} + } + + /** + * Deque contains all elements, in traversal order, of successful addAll + */ + public void testAddAll5() { + Integer[] empty = new Integer[0]; + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + assertFalse(q.addAll(Arrays.asList(empty))); + assertTrue(q.addAll(Arrays.asList(ints))); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); + } + + + /** + * put(null) throws NPE + */ + public void testPutNull() throws InterruptedException { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + q.put(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * all elements successfully put are contained + */ + public void testPut() throws InterruptedException { + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + Integer I = new Integer(i); + q.put(I); + assertTrue(q.contains(I)); + } + assertEquals(0, q.remainingCapacity()); + } + + /** + * put blocks interruptibly if full + */ + public void testBlockingPut() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) + q.put(i); + assertEquals(SIZE, q.size()); + assertEquals(0, q.remainingCapacity()); + try { + q.put(99); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + assertEquals(SIZE, q.size()); + assertEquals(0, q.remainingCapacity()); + } + + /** + * put blocks waiting for take when full + */ + public void testPutWithTake() throws InterruptedException { + final int capacity = 2; + final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < capacity + 1; i++) + q.put(i); + try { + q.put(99); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(q.remainingCapacity(), 0); + assertEquals(0, q.take()); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + assertEquals(q.remainingCapacity(), 0); + } + + /** + * timed offer times out if full and elements not taken + */ + public void testTimedOffer() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.put(new Object()); + q.put(new Object()); + assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS)); + try { + q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + t.interrupt(); + t.join(); + } + + /** + * take retrieves elements in FIFO order + */ + public void testTake() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.take()); + } + } + + /** + * take blocks interruptibly when empty + */ + public void testTakeFromEmpty() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + Thread t = new ThreadShouldThrow(InterruptedException.class) { + public void realRun() throws InterruptedException { + q.take(); + }}; + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + } + + /** + * Take removes existing elements until empty, then blocks interruptibly + */ + public void testBlockingTake() throws InterruptedException { + final LinkedBlockingDeque q = populatedDeque(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.take()); + } + try { + q.take(); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + } + + + /** + * poll succeeds unless empty + */ + public void testPoll() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll()); + } + assertNull(q.poll()); + } + + /** + * timed poll with zero timeout succeeds when non-empty, else times out + */ + public void testTimedPoll0() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(0, MILLISECONDS)); + } + assertNull(q.poll(0, MILLISECONDS)); + } + + /** + * timed poll with nonzero timeout succeeds when non-empty, else times out + */ + public void testTimedPoll() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS)); + } + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); + } + + /** + * Interrupted timed poll throws InterruptedException instead of + * returning timeout status + */ + public void testInterruptedTimedPoll() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS)); + } + try { + q.poll(SMALL_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + } + + /** + * timed poll before a delayed offer fails; after offer succeeds; + * on interruption throws + */ + public void testTimedPollWithOffer() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); + assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS)); + try { + q.poll(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS)); + t.interrupt(); + t.join(); + } + + + /** + * putFirst(null) throws NPE + */ + public void testPutFirstNull() throws InterruptedException { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + q.putFirst(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * all elements successfully putFirst are contained + */ + public void testPutFirst() throws InterruptedException { + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + Integer I = new Integer(i); + q.putFirst(I); + assertTrue(q.contains(I)); + } + assertEquals(0, q.remainingCapacity()); + } + + /** + * putFirst blocks interruptibly if full + */ + public void testBlockingPutFirst() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) + q.putFirst(i); + assertEquals(SIZE, q.size()); + assertEquals(0, q.remainingCapacity()); + try { + q.putFirst(99); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + assertEquals(SIZE, q.size()); + assertEquals(0, q.remainingCapacity()); + } + + /** + * putFirst blocks waiting for take when full + */ + public void testPutFirstWithTake() throws InterruptedException { + final int capacity = 2; + final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < capacity + 1; i++) + q.putFirst(i); + try { + q.putFirst(99); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(q.remainingCapacity(), 0); + assertEquals(capacity - 1, q.take()); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + assertEquals(q.remainingCapacity(), 0); + } + + /** + * timed offerFirst times out if full and elements not taken + */ + public void testTimedOfferFirst() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.putFirst(new Object()); + q.putFirst(new Object()); + assertFalse(q.offerFirst(new Object(), SHORT_DELAY_MS, MILLISECONDS)); + try { + q.offerFirst(new Object(), LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + t.interrupt(); + t.join(); + } + + /** + * take retrieves elements in FIFO order + */ + public void testTakeFirst() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.takeFirst()); + } + } + + /** + * takeFirst blocks interruptibly when empty + */ + public void testTakeFirstFromEmpty() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + Thread t = new ThreadShouldThrow(InterruptedException.class) { + public void realRun() throws InterruptedException { + q.takeFirst(); + }}; + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + } + + /** + * TakeFirst removes existing elements until empty, then blocks interruptibly + */ + public void testBlockingTakeFirst() throws InterruptedException { + final LinkedBlockingDeque q = populatedDeque(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) + assertEquals(i, q.takeFirst()); + try { + q.takeFirst(); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + } + + + /** + * timed pollFirst with zero timeout succeeds when non-empty, else times out + */ + public void testTimedPollFirst0() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.pollFirst(0, MILLISECONDS)); + } + assertNull(q.pollFirst(0, MILLISECONDS)); + } + + /** + * timed pollFirst with nonzero timeout succeeds when non-empty, else times out + */ + public void testTimedPollFirst() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)); + } + assertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)); + } + + /** + * Interrupted timed pollFirst throws InterruptedException instead of + * returning timeout status + */ + public void testInterruptedTimedPollFirst() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)); + } + try { + q.pollFirst(SMALL_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + } + + /** + * timed pollFirst before a delayed offerFirst fails; after offerFirst succeeds; + * on interruption throws + */ + public void testTimedPollFirstWithOfferFirst() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)); + assertSame(zero, q.pollFirst(LONG_DELAY_MS, MILLISECONDS)); + try { + q.pollFirst(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + assertTrue(q.offerFirst(zero, SHORT_DELAY_MS, MILLISECONDS)); + t.interrupt(); + t.join(); + } + + /** + * putLast(null) throws NPE + */ + public void testPutLastNull() throws InterruptedException { + try { + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + q.putLast(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * all elements successfully putLast are contained + */ + public void testPutLast() throws InterruptedException { + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + Integer I = new Integer(i); + q.putLast(I); + assertTrue(q.contains(I)); + } + assertEquals(0, q.remainingCapacity()); + } + + /** + * putLast blocks interruptibly if full + */ + public void testBlockingPutLast() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) + q.putLast(i); + assertEquals(SIZE, q.size()); + assertEquals(0, q.remainingCapacity()); + try { + q.putLast(99); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + assertEquals(SIZE, q.size()); + assertEquals(0, q.remainingCapacity()); + } + + /** + * putLast blocks waiting for take when full + */ + public void testPutLastWithTake() throws InterruptedException { + final int capacity = 2; + final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < capacity + 1; i++) + q.putLast(i); + try { + q.putLast(99); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(q.remainingCapacity(), 0); + assertEquals(0, q.take()); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + assertEquals(q.remainingCapacity(), 0); + } + + /** + * timed offerLast times out if full and elements not taken + */ + public void testTimedOfferLast() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.putLast(new Object()); + q.putLast(new Object()); + assertFalse(q.offerLast(new Object(), SHORT_DELAY_MS, MILLISECONDS)); + try { + q.offerLast(new Object(), LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + t.interrupt(); + t.join(); + } + + /** + * takeLast retrieves elements in FIFO order + */ + public void testTakeLast() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(SIZE-i-1, q.takeLast()); + } + } + + /** + * takeLast blocks interruptibly when empty + */ + public void testTakeLastFromEmpty() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + Thread t = new ThreadShouldThrow(InterruptedException.class) { + public void realRun() throws InterruptedException { + q.takeLast(); + }}; + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + } + + /** + * TakeLast removes existing elements until empty, then blocks interruptibly + */ + public void testBlockingTakeLast() throws InterruptedException { + final LinkedBlockingDeque q = populatedDeque(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) + assertEquals(SIZE - 1 - i, q.takeLast()); + try { + q.takeLast(); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + } + + /** + * timed pollLast with zero timeout succeeds when non-empty, else times out + */ + public void testTimedPollLast0() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(SIZE-i-1, q.pollLast(0, MILLISECONDS)); + } + assertNull(q.pollLast(0, MILLISECONDS)); + } + + /** + * timed pollLast with nonzero timeout succeeds when non-empty, else times out + */ + public void testTimedPollLast() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(SIZE-i-1, q.pollLast(SHORT_DELAY_MS, MILLISECONDS)); + } + assertNull(q.pollLast(SHORT_DELAY_MS, MILLISECONDS)); + } + + /** + * Interrupted timed pollLast throws InterruptedException instead of + * returning timeout status + */ + public void testInterruptedTimedPollLast() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(SIZE-i-1, q.pollLast(SHORT_DELAY_MS, MILLISECONDS)); + } + try { + q.pollLast(SMALL_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + } + + /** + * timed poll before a delayed offerLast fails; after offerLast succeeds; + * on interruption throws + */ + public void testTimedPollWithOfferLast() throws InterruptedException { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); + assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS)); + try { + q.poll(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + assertTrue(q.offerLast(zero, SHORT_DELAY_MS, MILLISECONDS)); + t.interrupt(); + t.join(); + } + + + /** + * element returns next element, or throws NSEE if empty + */ + public void testElement() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.element()); + q.poll(); + } + try { + q.element(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } + + /** + * remove(x) removes x and returns true if present + */ + public void testRemoveElement() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 1; i < SIZE; i+=2) { + assertTrue(q.remove(new Integer(i))); + } + for (int i = 0; i < SIZE; i+=2) { + assertTrue(q.remove(new Integer(i))); + assertFalse(q.remove(new Integer(i+1))); + } + assertTrue(q.isEmpty()); + } + + /** + * contains(x) reports true when elements added but not yet removed + */ + public void testContains() { + LinkedBlockingDeque q = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertTrue(q.contains(new Integer(i))); + q.poll(); + assertFalse(q.contains(new Integer(i))); + } + } + + /** + * clear removes all elements + */ + public void testClear() { + LinkedBlockingDeque q = populatedDeque(SIZE); + q.clear(); + assertTrue(q.isEmpty()); + assertEquals(0, q.size()); + assertEquals(SIZE, q.remainingCapacity()); + q.add(one); + assertFalse(q.isEmpty()); + assertTrue(q.contains(one)); + q.clear(); + assertTrue(q.isEmpty()); + } + + /** + * containsAll(c) is true when c contains a subset of elements + */ + public void testContainsAll() { + LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque p = new LinkedBlockingDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertTrue(q.containsAll(p)); + assertFalse(p.containsAll(q)); + p.add(new Integer(i)); + } + assertTrue(p.containsAll(q)); + } + + /** + * retainAll(c) retains only those elements of c and reports true if changed + */ + public void testRetainAll() { + LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque p = populatedDeque(SIZE); + for (int i = 0; i < SIZE; ++i) { + boolean changed = q.retainAll(p); + if (i == 0) + assertFalse(changed); + else + assertTrue(changed); + + assertTrue(q.containsAll(p)); + assertEquals(SIZE-i, q.size()); + p.remove(); + } + } + + /** + * removeAll(c) removes only those elements of c and reports true if changed + */ + public void testRemoveAll() { + for (int i = 1; i < SIZE; ++i) { + LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque p = populatedDeque(i); + assertTrue(q.removeAll(p)); + assertEquals(SIZE-i, q.size()); + for (int j = 0; j < i; ++j) { + Integer I = (Integer)(p.remove()); + assertFalse(q.contains(I)); + } + } + } + + /** + * toArray contains all elements + */ + public void testToArray() throws InterruptedException{ + LinkedBlockingDeque q = populatedDeque(SIZE); + Object[] o = q.toArray(); + for (int i = 0; i < o.length; i++) + assertEquals(o[i], q.take()); + } + + /** + * toArray(a) contains all elements + */ + public void testToArray2() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + Integer[] ints = new Integer[SIZE]; + ints = (Integer[])q.toArray(ints); + for (int i = 0; i < ints.length; i++) + assertEquals(ints[i], q.take()); + } + + /** + * toArray(null) throws NPE + */ + public void testToArray_BadArg() { + LinkedBlockingDeque q = populatedDeque(SIZE); + try { + Object o[] = q.toArray(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * toArray with incompatible array type throws CCE + */ + public void testToArray1_BadArg() { + LinkedBlockingDeque q = populatedDeque(SIZE); + try { + Object o[] = q.toArray(new String[10]); + shouldThrow(); + } catch (ArrayStoreException success) {} + } + + + /** + * iterator iterates through all elements + */ + public void testIterator() throws InterruptedException { + LinkedBlockingDeque q = populatedDeque(SIZE); + Iterator it = q.iterator(); + while (it.hasNext()) { + assertEquals(it.next(), q.take()); + } + } + + /** + * iterator.remove removes current element + */ + public void testIteratorRemove () { + final LinkedBlockingDeque q = new LinkedBlockingDeque(3); + q.add(two); + q.add(one); + q.add(three); + + Iterator it = q.iterator(); + it.next(); + it.remove(); + + it = q.iterator(); + assertSame(it.next(), one); + assertSame(it.next(), three); + assertFalse(it.hasNext()); + } + + + /** + * iterator ordering is FIFO + */ + public void testIteratorOrdering() { + final LinkedBlockingDeque q = new LinkedBlockingDeque(3); + q.add(one); + q.add(two); + q.add(three); + assertEquals(0, q.remainingCapacity()); + int k = 0; + for (Iterator it = q.iterator(); it.hasNext();) { + assertEquals(++k, it.next()); + } + assertEquals(3, k); + } + + /** + * Modifications do not cause iterators to fail + */ + public void testWeaklyConsistentIteration () { + final LinkedBlockingDeque q = new LinkedBlockingDeque(3); + q.add(one); + q.add(two); + q.add(three); + for (Iterator it = q.iterator(); it.hasNext();) { + q.remove(); + it.next(); + } + assertEquals(0, q.size()); + } + + + /** + * Descending iterator iterates through all elements + */ + public void testDescendingIterator() { + LinkedBlockingDeque q = populatedDeque(SIZE); + int i = 0; + Iterator it = q.descendingIterator(); + while (it.hasNext()) { + assertTrue(q.contains(it.next())); + ++i; + } + assertEquals(i, SIZE); + assertFalse(it.hasNext()); + try { + it.next(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } + + /** + * Descending iterator ordering is reverse FIFO + */ + public void testDescendingIteratorOrdering() { + final LinkedBlockingDeque q = new LinkedBlockingDeque(); + for (int iters = 0; iters < 100; ++iters) { + q.add(new Integer(3)); + q.add(new Integer(2)); + q.add(new Integer(1)); + int k = 0; + for (Iterator it = q.descendingIterator(); it.hasNext();) { + assertEquals(++k, it.next()); + } + + assertEquals(3, k); + q.remove(); + q.remove(); + q.remove(); + } + } + + /** + * descendingIterator.remove removes current element + */ + public void testDescendingIteratorRemove () { + final LinkedBlockingDeque q = new LinkedBlockingDeque(); + for (int iters = 0; iters < 100; ++iters) { + q.add(new Integer(3)); + q.add(new Integer(2)); + q.add(new Integer(1)); + Iterator it = q.descendingIterator(); + assertEquals(it.next(), new Integer(1)); + it.remove(); + assertEquals(it.next(), new Integer(2)); + it = q.descendingIterator(); + assertEquals(it.next(), new Integer(2)); + assertEquals(it.next(), new Integer(3)); + it.remove(); + assertFalse(it.hasNext()); + q.remove(); + } + } + + + /** + * toString contains toStrings of elements + */ + public void testToString() { + LinkedBlockingDeque q = populatedDeque(SIZE); + String s = q.toString(); + for (int i = 0; i < SIZE; ++i) { + assertTrue(s.indexOf(String.valueOf(i)) >= 0); + } + } + + + /** + * offer transfers elements across Executor tasks + */ + public void testOfferInExecutor() { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + q.add(one); + q.add(two); + ExecutorService executor = Executors.newFixedThreadPool(2); + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(q.offer(three)); + assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS)); + assertEquals(0, q.remainingCapacity()); + }}); + + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); + assertSame(one, q.take()); + }}); + + joinPool(executor); + } + + /** + * poll retrieves elements across Executor threads + */ + public void testPollInExecutor() { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + ExecutorService executor = Executors.newFixedThreadPool(2); + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll()); + assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS)); + assertTrue(q.isEmpty()); + }}); + + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); + q.put(one); + }}); + + joinPool(executor); + } + + /** + * A deserialized serialized deque has same elements in same order + */ + public void testSerialization() throws Exception { + LinkedBlockingDeque q = populatedDeque(SIZE); + + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + LinkedBlockingDeque r = (LinkedBlockingDeque)in.readObject(); + assertEquals(q.size(), r.size()); + while (!q.isEmpty()) + assertEquals(q.remove(), r.remove()); + } + + /** + * drainTo(null) throws NPE + */ + public void testDrainToNull() { + LinkedBlockingDeque q = populatedDeque(SIZE); + try { + q.drainTo(null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * drainTo(this) throws IAE + */ + public void testDrainToSelf() { + LinkedBlockingDeque q = populatedDeque(SIZE); + try { + q.drainTo(q); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * drainTo(c) empties deque into another collection c + */ + public void testDrainTo() { + LinkedBlockingDeque q = populatedDeque(SIZE); + ArrayList l = new ArrayList(); + q.drainTo(l); + assertEquals(q.size(), 0); + assertEquals(l.size(), SIZE); + for (int i = 0; i < SIZE; ++i) + assertEquals(l.get(i), new Integer(i)); + q.add(zero); + q.add(one); + assertFalse(q.isEmpty()); + assertTrue(q.contains(zero)); + assertTrue(q.contains(one)); + l.clear(); + q.drainTo(l); + assertEquals(q.size(), 0); + assertEquals(l.size(), 2); + for (int i = 0; i < 2; ++i) + assertEquals(l.get(i), new Integer(i)); + } + + /** + * drainTo empties full deque, unblocking a waiting put. + */ + public void testDrainToWithActivePut() throws InterruptedException { + final LinkedBlockingDeque q = populatedDeque(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.put(new Integer(SIZE+1)); + }}); + + t.start(); + ArrayList l = new ArrayList(); + q.drainTo(l); + assertTrue(l.size() >= SIZE); + for (int i = 0; i < SIZE; ++i) + assertEquals(l.get(i), new Integer(i)); + t.join(); + assertTrue(q.size() + l.size() >= SIZE); + } + + /** + * drainTo(null, n) throws NPE + */ + public void testDrainToNullN() { + LinkedBlockingDeque q = populatedDeque(SIZE); + try { + q.drainTo(null, 0); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * drainTo(this, n) throws IAE + */ + public void testDrainToSelfN() { + LinkedBlockingDeque q = populatedDeque(SIZE); + try { + q.drainTo(q, 0); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * drainTo(c, n) empties first max {n, size} elements of deque into c + */ + public void testDrainToN() { + LinkedBlockingDeque q = new LinkedBlockingDeque(); + for (int i = 0; i < SIZE + 2; ++i) { + for (int j = 0; j < SIZE; j++) + assertTrue(q.offer(new Integer(j))); + ArrayList l = new ArrayList(); + q.drainTo(l, i); + int k = (i < SIZE)? i : SIZE; + assertEquals(l.size(), k); + assertEquals(q.size(), SIZE-k); + for (int j = 0; j < k; ++j) + assertEquals(l.get(j), new Integer(j)); + while (q.poll() != null) ; + } + } + +} diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/LinkedBlockingQueueTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/LinkedBlockingQueueTest.java index dd6be9a..a98dc21 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/LinkedBlockingQueueTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/LinkedBlockingQueueTest.java @@ -2,15 +2,16 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.io.*; public class LinkedBlockingQueueTest extends JSR166TestCase { @@ -26,7 +27,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { private LinkedBlockingQueue populatedQueue(int n) { LinkedBlockingQueue q = new LinkedBlockingQueue(n); assertTrue(q.isEmpty()); - for(int i = 0; i < n; i++) + for (int i = 0; i < n; i++) assertTrue(q.offer(new Integer(i))); assertFalse(q.isEmpty()); assertEquals(0, q.remainingCapacity()); @@ -44,14 +45,13 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { } /** - * Constructor throws IAE if capacity argument nonpositive + * Constructor throws IAE if capacity argument nonpositive */ public void testConstructor2() { try { LinkedBlockingQueue q = new LinkedBlockingQueue(0); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } /** @@ -61,8 +61,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { try { LinkedBlockingQueue q = new LinkedBlockingQueue(null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -73,8 +72,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -87,23 +85,19 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { ints[i] = new Integer(i); LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * Queue contains all elements of collection used to initialize */ public void testConstructor6() { - try { - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints)); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); - } - finally {} + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints)); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); } /** @@ -146,7 +140,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { LinkedBlockingQueue q = new LinkedBlockingQueue(1); q.offer(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -157,7 +151,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { LinkedBlockingQueue q = new LinkedBlockingQueue(1); q.add(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -180,8 +174,8 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { } assertEquals(0, q.remainingCapacity()); q.add(new Integer(SIZE)); - } catch (IllegalStateException success){ - } + shouldThrow(); + } catch (IllegalStateException success) {} } /** @@ -192,8 +186,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { LinkedBlockingQueue q = new LinkedBlockingQueue(1); q.addAll(null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -204,8 +197,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { LinkedBlockingQueue q = populatedQueue(SIZE); q.addAll(q); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } /** @@ -217,8 +209,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll of a collection with any null elements throws NPE after @@ -232,8 +223,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { ints[i] = new Integer(i); q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll throws ISE if not enough room @@ -246,224 +236,175 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { ints[i] = new Integer(i); q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (IllegalStateException success) {} + } catch (IllegalStateException success) {} } /** * Queue contains all elements, in traversal order, of successful addAll */ public void testAddAll5() { - try { - Integer[] empty = new Integer[0]; - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE); - assertFalse(q.addAll(Arrays.asList(empty))); - assertTrue(q.addAll(Arrays.asList(ints))); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); - } - finally {} + Integer[] empty = new Integer[0]; + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE); + assertFalse(q.addAll(Arrays.asList(empty))); + assertTrue(q.addAll(Arrays.asList(ints))); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); } /** * put(null) throws NPE */ - public void testPutNull() { + public void testPutNull() throws InterruptedException { try { LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE); q.put(null); shouldThrow(); - } - catch (NullPointerException success){ - } - catch (InterruptedException ie) { - unexpectedException(); - } + } catch (NullPointerException success) {} } /** * all elements successfully put are contained */ - public void testPut() { - try { - LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - Integer I = new Integer(i); - q.put(I); - assertTrue(q.contains(I)); - } - assertEquals(0, q.remainingCapacity()); - } - catch (InterruptedException ie) { - unexpectedException(); + public void testPut() throws InterruptedException { + LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + Integer I = new Integer(i); + q.put(I); + assertTrue(q.contains(I)); } + assertEquals(0, q.remainingCapacity()); } /** * put blocks interruptibly if full */ - public void testBlockingPut() { - Thread t = new Thread(new Runnable() { - public void run() { - int added = 0; - try { - LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - q.put(new Integer(i)); - ++added; - } - q.put(new Integer(SIZE)); - threadShouldThrow(); - } catch (InterruptedException ie){ - threadAssertEquals(added, SIZE); - } - }}); + public void testBlockingPut() throws InterruptedException { + final LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) + q.put(i); + assertEquals(SIZE, q.size()); + assertEquals(0, q.remainingCapacity()); + try { + q.put(99); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + assertEquals(SIZE, q.size()); + assertEquals(0, q.remainingCapacity()); } /** * put blocks waiting for take when full */ - public void testPutWithTake() { + public void testPutWithTake() throws InterruptedException { + final int capacity = 2; final LinkedBlockingQueue q = new LinkedBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - int added = 0; - try { - q.put(new Object()); - ++added; - q.put(new Object()); - ++added; - q.put(new Object()); - ++added; - q.put(new Object()); - ++added; - threadShouldThrow(); - } catch (InterruptedException e){ - threadAssertTrue(added >= 2); - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - q.take(); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < capacity + 1; i++) + q.put(i); + try { + q.put(99); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(q.remainingCapacity(), 0); + assertEquals(0, q.take()); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + assertEquals(q.remainingCapacity(), 0); } /** * timed offer times out if full and elements not taken */ - public void testTimedOffer() { + public void testTimedOffer() throws InterruptedException { final LinkedBlockingQueue q = new LinkedBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.put(new Object()); - q.put(new Object()); - threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch (InterruptedException success){} - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.put(new Object()); + q.put(new Object()); + assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS)); + try { + q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); - try { - t.start(); - Thread.sleep(SMALL_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + t.start(); + Thread.sleep(SMALL_DELAY_MS); + t.interrupt(); + t.join(); } /** * take retrieves elements in FIFO order */ - public void testTake() { - try { - LinkedBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.take()).intValue()); - } - } catch (InterruptedException e){ - unexpectedException(); + public void testTake() throws InterruptedException { + LinkedBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.take()); } } /** * take blocks interruptibly when empty */ - public void testTakeFromEmpty() { + public void testTakeFromEmpty() throws InterruptedException { final LinkedBlockingQueue q = new LinkedBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.take(); - threadShouldThrow(); - } catch (InterruptedException success){ } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new ThreadShouldThrow(InterruptedException.class) { + public void realRun() throws InterruptedException { + q.take(); + }}; + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * Take removes existing elements until empty, then blocks interruptibly */ - public void testBlockingTake() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - LinkedBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.take()).intValue()); - } - q.take(); - threadShouldThrow(); - } catch (InterruptedException success){ - } - }}); + public void testBlockingTake() throws InterruptedException { + final LinkedBlockingQueue q = populatedQueue(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.take()); + } + try { + q.take(); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } - /** * poll succeeds unless empty */ public void testPoll() { LinkedBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.poll()).intValue()); + assertEquals(i, q.poll()); } assertNull(q.poll()); } @@ -471,85 +412,69 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { /** * timed pool with zero timeout succeeds when non-empty, else times out */ - public void testTimedPoll0() { - try { - LinkedBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue()); - } - assertNull(q.poll(0, TimeUnit.MILLISECONDS)); - } catch (InterruptedException e){ - unexpectedException(); + public void testTimedPoll0() throws InterruptedException { + LinkedBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(0, MILLISECONDS)); } + assertNull(q.poll(0, MILLISECONDS)); } /** * timed pool with nonzero timeout succeeds when non-empty, else times out */ - public void testTimedPoll() { - try { - LinkedBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue()); - } - assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (InterruptedException e){ - unexpectedException(); + public void testTimedPoll() throws InterruptedException { + LinkedBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS)); } + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); } /** * Interrupted timed poll throws InterruptedException instead of * returning timeout status */ - public void testInterruptedTimedPoll() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - LinkedBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue()); - } - threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (InterruptedException success){ - } - }}); + public void testInterruptedTimedPoll() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + LinkedBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS)); + } + try { + q.poll(SMALL_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * timed poll before a delayed offer fails; after offer succeeds; * on interruption throws */ - public void testTimedPollWithOffer() { + public void testTimedPollWithOffer() throws InterruptedException { final LinkedBlockingQueue q = new LinkedBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch (InterruptedException success) { } - } - }); - try { - t.start(); - Thread.sleep(SMALL_DELAY_MS); - assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); + assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS)); + try { + q.poll(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS)); + t.interrupt(); + t.join(); } /** @@ -558,10 +483,10 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { public void testPeek() { LinkedBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.peek()).intValue()); - q.poll(); + assertEquals(i, q.peek()); + assertEquals(i, q.poll()); assertTrue(q.peek() == null || - i != ((Integer)q.peek()).intValue()); + !q.peek().equals(i)); } assertNull(q.peek()); } @@ -572,14 +497,13 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { public void testElement() { LinkedBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.element()).intValue()); - q.poll(); + assertEquals(i, q.element()); + assertEquals(i, q.poll()); } try { q.element(); shouldThrow(); - } - catch (NoSuchElementException success) {} + } catch (NoSuchElementException success) {} } /** @@ -588,13 +512,12 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { public void testRemove() { LinkedBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.remove()).intValue()); + assertEquals(i, q.remove()); } try { q.remove(); shouldThrow(); - } catch (NoSuchElementException success){ - } + } catch (NoSuchElementException success) {} } /** @@ -615,18 +538,14 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { /** * An add following remove(x) succeeds */ - public void testRemoveElementAndAdd() { - try { - LinkedBlockingQueue q = new LinkedBlockingQueue(); - assertTrue(q.add(new Integer(1))); - assertTrue(q.add(new Integer(2))); - assertTrue(q.remove(new Integer(1))); - assertTrue(q.remove(new Integer(2))); - assertTrue(q.add(new Integer(3))); - assertTrue(q.take() != null); - } catch (Exception e){ - unexpectedException(); - } + public void testRemoveElementAndAdd() throws InterruptedException { + LinkedBlockingQueue q = new LinkedBlockingQueue(); + assertTrue(q.add(new Integer(1))); + assertTrue(q.add(new Integer(2))); + assertTrue(q.remove(new Integer(1))); + assertTrue(q.remove(new Integer(2))); + assertTrue(q.add(new Integer(3))); + assertTrue(q.take() != null); } /** @@ -709,67 +628,55 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { /** * toArray contains all elements */ - public void testToArray() { + public void testToArray() throws InterruptedException { LinkedBlockingQueue q = populatedQueue(SIZE); Object[] o = q.toArray(); - try { - for(int i = 0; i < o.length; i++) + for (int i = 0; i < o.length; i++) assertEquals(o[i], q.take()); - } catch (InterruptedException e){ - unexpectedException(); - } } /** * toArray(a) contains all elements */ - public void testToArray2() { + public void testToArray2() throws InterruptedException { LinkedBlockingQueue q = populatedQueue(SIZE); Integer[] ints = new Integer[SIZE]; ints = (Integer[])q.toArray(ints); - try { - for(int i = 0; i < ints.length; i++) - assertEquals(ints[i], q.take()); - } catch (InterruptedException e){ - unexpectedException(); - } + for (int i = 0; i < ints.length; i++) + assertEquals(ints[i], q.take()); } /** * toArray(null) throws NPE */ public void testToArray_BadArg() { + LinkedBlockingQueue q = populatedQueue(SIZE); try { - LinkedBlockingQueue q = populatedQueue(SIZE); Object o[] = q.toArray(null); shouldThrow(); - } catch(NullPointerException success){} + } catch (NullPointerException success) {} } /** * toArray with incompatible array type throws CCE */ public void testToArray1_BadArg() { + LinkedBlockingQueue q = populatedQueue(SIZE); try { - LinkedBlockingQueue q = populatedQueue(SIZE); - Object o[] = q.toArray(new String[10] ); + Object o[] = q.toArray(new String[10]); shouldThrow(); - } catch(ArrayStoreException success){} + } catch (ArrayStoreException success) {} } /** * iterator iterates through all elements */ - public void testIterator() { + public void testIterator() throws InterruptedException { LinkedBlockingQueue q = populatedQueue(SIZE); Iterator it = q.iterator(); - try { - while(it.hasNext()){ - assertEquals(it.next(), q.take()); - } - } catch (InterruptedException e){ - unexpectedException(); + while (it.hasNext()) { + assertEquals(it.next(), q.take()); } } @@ -787,8 +694,8 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { it.remove(); it = q.iterator(); - assertEquals(it.next(), one); - assertEquals(it.next(), three); + assertSame(it.next(), one); + assertSame(it.next(), three); assertFalse(it.hasNext()); } @@ -804,8 +711,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { assertEquals(0, q.remainingCapacity()); int k = 0; for (Iterator it = q.iterator(); it.hasNext();) { - int i = ((Integer)(it.next())).intValue(); - assertEquals(++k, i); + assertEquals(++k, it.next()); } assertEquals(3, k); } @@ -818,14 +724,9 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { q.add(one); q.add(two); q.add(three); - try { - for (Iterator it = q.iterator(); it.hasNext();) { - q.remove(); - it.next(); - } - } - catch (ConcurrentModificationException e) { - unexpectedException(); + for (Iterator it = q.iterator(); it.hasNext();) { + q.remove(); + it.next(); } assertEquals(0, q.size()); } @@ -851,30 +752,18 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { q.add(one); q.add(two); ExecutorService executor = Executors.newFixedThreadPool(2); - executor.execute(new Runnable() { - public void run() { - threadAssertFalse(q.offer(three)); - try { - threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertEquals(0, q.remainingCapacity()); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - executor.execute(new Runnable() { - public void run() { - try { - Thread.sleep(SMALL_DELAY_MS); - threadAssertEquals(one, q.take()); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(q.offer(three)); + assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS)); + assertEquals(0, q.remainingCapacity()); + }}); + + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); + assertSame(one, q.take()); + }}); joinPool(executor); } @@ -885,30 +774,18 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { public void testPollInExecutor() { final LinkedBlockingQueue q = new LinkedBlockingQueue(2); ExecutorService executor = Executors.newFixedThreadPool(2); - executor.execute(new Runnable() { - public void run() { - threadAssertNull(q.poll()); - try { - threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(q.isEmpty()); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - executor.execute(new Runnable() { - public void run() { - try { - Thread.sleep(SMALL_DELAY_MS); - q.put(one); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll()); + assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS)); + assertTrue(q.isEmpty()); + }}); + + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); + q.put(one); + }}); joinPool(executor); } @@ -916,24 +793,20 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { /** * A deserialized serialized queue has same elements in same order */ - public void testSerialization() { + public void testSerialization() throws Exception { LinkedBlockingQueue q = populatedQueue(SIZE); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(q); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - LinkedBlockingQueue r = (LinkedBlockingQueue)in.readObject(); - assertEquals(q.size(), r.size()); - while (!q.isEmpty()) - assertEquals(q.remove(), r.remove()); - } catch(Exception e){ - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + LinkedBlockingQueue r = (LinkedBlockingQueue)in.readObject(); + assertEquals(q.size(), r.size()); + while (!q.isEmpty()) + assertEquals(q.remove(), r.remove()); } /** @@ -944,8 +817,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { try { q.drainTo(null); shouldThrow(); - } catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** @@ -956,8 +828,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { try { q.drainTo(q); shouldThrow(); - } catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } /** @@ -987,29 +858,21 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { /** * drainTo empties full queue, unblocking a waiting put. */ - public void testDrainToWithActivePut() { + public void testDrainToWithActivePut() throws InterruptedException { final LinkedBlockingQueue q = populatedQueue(SIZE); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.put(new Integer(SIZE+1)); - } catch (InterruptedException ie){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - ArrayList l = new ArrayList(); - q.drainTo(l); - assertTrue(l.size() >= SIZE); - for (int i = 0; i < SIZE; ++i) - assertEquals(l.get(i), new Integer(i)); - t.join(); - assertTrue(q.size() + l.size() >= SIZE); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.put(new Integer(SIZE+1)); + }}); + + t.start(); + ArrayList l = new ArrayList(); + q.drainTo(l); + assertTrue(l.size() >= SIZE); + for (int i = 0; i < SIZE; ++i) + assertEquals(l.get(i), new Integer(i)); + t.join(); + assertTrue(q.size() + l.size() >= SIZE); } /** @@ -1020,8 +883,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { try { q.drainTo(null, 0); shouldThrow(); - } catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** @@ -1032,8 +894,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { try { q.drainTo(q, 0); shouldThrow(); - } catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } /** @@ -1042,7 +903,7 @@ public class LinkedBlockingQueueTest extends JSR166TestCase { public void testDrainToN() { LinkedBlockingQueue q = new LinkedBlockingQueue(); for (int i = 0; i < SIZE + 2; ++i) { - for(int j = 0; j < SIZE; j++) + for (int j = 0; j < SIZE; j++) assertTrue(q.offer(new Integer(j))); ArrayList l = new ArrayList(); q.drainTo(l, i); diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/LockSupportTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/LockSupportTest.java index 0a74f91..1052a24 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/LockSupportTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/LockSupportTest.java @@ -2,18 +2,18 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; import java.util.concurrent.locks.*; -public class LockSupportTest extends JSR166TestCase{ +public class LockSupportTest extends JSR166TestCase { public static Test suite() { return new TestSuite(LockSupportTest.class); } @@ -21,145 +21,92 @@ public class LockSupportTest extends JSR166TestCase{ /** * park is released by unpark occurring after park */ - public void testPark() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - LockSupport.park(); - } catch(Exception e){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - LockSupport.unpark(t); - t.join(); - } - catch(Exception e) { - unexpectedException(); - } + public void testPark() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + LockSupport.park(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + LockSupport.unpark(t); + t.join(); } /** * park is released by unpark occurring before park */ - public void testPark2() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - Thread.sleep(SHORT_DELAY_MS); - LockSupport.park(); - } catch(Exception e){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - LockSupport.unpark(t); - t.join(); - } - catch(Exception e) { - unexpectedException(); - } + public void testPark2() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SHORT_DELAY_MS); + LockSupport.park(); + }}); + + t.start(); + LockSupport.unpark(t); + t.join(); } /** * park is released by interrupt */ - public void testPark3() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - LockSupport.park(); - } catch(Exception e){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch(Exception e) { - unexpectedException(); - } + public void testPark3() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + LockSupport.park(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * park returns if interrupted before park */ - public void testPark4() { + public void testPark4() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); lock.lock(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - LockSupport.park(); - } catch(Exception e){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - t.interrupt(); - lock.unlock(); - t.join(); - } - catch(Exception e) { - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + lock.lock(); + LockSupport.park(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + lock.unlock(); + t.join(); } /** * parkNanos times out if not unparked */ - public void testParkNanos() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - LockSupport.parkNanos(1000); - } catch(Exception e){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - t.join(); - } - catch(Exception e) { - unexpectedException(); - } + public void testParkNanos() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + LockSupport.parkNanos(1000); + }}); + + t.start(); + t.join(); } /** * parkUntil times out if not unparked */ - public void testParkUntil() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - long d = new Date().getTime() + 100; - LockSupport.parkUntil(d); - } catch(Exception e){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - t.join(); - } - catch(Exception e) { - unexpectedException(); - } + public void testParkUntil() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + long d = new Date().getTime() + 100; + LockSupport.parkUntil(d); + }}); + + t.start(); + t.join(); } } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/PriorityBlockingQueueTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/PriorityBlockingQueueTest.java index a764866..f1dd88d 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/PriorityBlockingQueueTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/PriorityBlockingQueueTest.java @@ -2,15 +2,16 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.io.*; public class PriorityBlockingQueueTest extends JSR166TestCase { @@ -21,13 +22,9 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { private static final int NOCAP = Integer.MAX_VALUE; /** Sample Comparator */ - static class MyReverseComparator implements Comparator { + static class MyReverseComparator implements Comparator { public int compare(Object x, Object y) { - int i = ((Integer)x).intValue(); - int j = ((Integer)y).intValue(); - if (i < j) return 1; - if (i > j) return -1; - return 0; + return ((Comparable)y).compareTo(x); } } @@ -38,16 +35,16 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { private PriorityBlockingQueue populatedQueue(int n) { PriorityBlockingQueue q = new PriorityBlockingQueue(n); assertTrue(q.isEmpty()); - for(int i = n-1; i >= 0; i-=2) + for (int i = n-1; i >= 0; i-=2) assertTrue(q.offer(new Integer(i))); - for(int i = (n & 1); i < n; i+=2) + for (int i = (n & 1); i < n; i+=2) assertTrue(q.offer(new Integer(i))); assertFalse(q.isEmpty()); assertEquals(NOCAP, q.remainingCapacity()); assertEquals(n, q.size()); return q; } - + /** * A new queue has unbounded capacity */ @@ -56,14 +53,13 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { } /** - * Constructor throws IAE if capacity argument nonpositive + * Constructor throws IAE if capacity argument nonpositive */ public void testConstructor2() { try { PriorityBlockingQueue q = new PriorityBlockingQueue(0); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } /** @@ -73,8 +69,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { try { PriorityBlockingQueue q = new PriorityBlockingQueue(null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -85,8 +80,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -99,41 +93,34 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { ints[i] = new Integer(i); PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * Queue contains all elements of collection used to initialize */ public void testConstructor6() { - try { - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints)); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); - } - finally {} + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints)); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); } /** * The comparator used in constructor is used */ public void testConstructor7() { - try { - MyReverseComparator cmp = new MyReverseComparator(); - PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE, cmp); - assertEquals(cmp, q.comparator()); - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - q.addAll(Arrays.asList(ints)); - for (int i = SIZE-1; i >= 0; --i) - assertEquals(ints[i], q.poll()); - } - finally {} + MyReverseComparator cmp = new MyReverseComparator(); + PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE, cmp); + assertEquals(cmp, q.comparator()); + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + q.addAll(Arrays.asList(ints)); + for (int i = SIZE-1; i >= 0; --i) + assertEquals(ints[i], q.poll()); } /** @@ -177,7 +164,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { PriorityBlockingQueue q = new PriorityBlockingQueue(1); q.offer(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -188,7 +175,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { PriorityBlockingQueue q = new PriorityBlockingQueue(1); q.add(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -210,8 +197,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { q.offer(new Object()); q.offer(new Object()); shouldThrow(); - } - catch(ClassCastException success) {} + } catch (ClassCastException success) {} } /** @@ -233,8 +219,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { PriorityBlockingQueue q = new PriorityBlockingQueue(1); q.addAll(null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -245,8 +230,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { PriorityBlockingQueue q = populatedQueue(SIZE); q.addAll(q); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } /** @@ -258,8 +242,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll of a collection with any null elements throws NPE after @@ -273,26 +256,22 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { ints[i] = new Integer(i); q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * Queue contains all elements of successful addAll */ public void testAddAll5() { - try { - Integer[] empty = new Integer[0]; - Integer[] ints = new Integer[SIZE]; - for (int i = SIZE-1; i >= 0; --i) - ints[i] = new Integer(i); - PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE); - assertFalse(q.addAll(Arrays.asList(empty))); - assertTrue(q.addAll(Arrays.asList(ints))); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); - } - finally {} + Integer[] empty = new Integer[0]; + Integer[] ints = new Integer[SIZE]; + for (int i = SIZE-1; i >= 0; --i) + ints[i] = new Integer(i); + PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE); + assertFalse(q.addAll(Arrays.asList(empty))); + assertTrue(q.addAll(Arrays.asList(ints))); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); } /** @@ -303,149 +282,107 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE); q.put(null); shouldThrow(); - } - catch (NullPointerException success){ - } + } catch (NullPointerException success) {} } /** * all elements successfully put are contained */ public void testPut() { - try { - PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - Integer I = new Integer(i); - q.put(I); - assertTrue(q.contains(I)); - } - assertEquals(SIZE, q.size()); + PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + Integer I = new Integer(i); + q.put(I); + assertTrue(q.contains(I)); } - finally { - } + assertEquals(SIZE, q.size()); } /** * put doesn't block waiting for take */ - public void testPutWithTake() { + public void testPutWithTake() throws InterruptedException { final PriorityBlockingQueue q = new PriorityBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - int added = 0; - try { - q.put(new Integer(0)); - ++added; - q.put(new Integer(0)); - ++added; - q.put(new Integer(0)); - ++added; - q.put(new Integer(0)); - ++added; - threadAssertTrue(added == 4); - } finally { - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - q.take(); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + final int size = 4; + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + for (int i = 0; i < size; i++) + q.put(new Integer(0)); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(q.size(), size); + q.take(); + t.interrupt(); + t.join(); } /** * timed offer does not time out */ - public void testTimedOffer() { + public void testTimedOffer() throws InterruptedException { final PriorityBlockingQueue q = new PriorityBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.put(new Integer(0)); - q.put(new Integer(0)); - threadAssertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(q.offer(new Integer(0), LONG_DELAY_MS, TimeUnit.MILLISECONDS)); - } finally { } - } - }); - - try { - t.start(); - Thread.sleep(SMALL_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + q.put(new Integer(0)); + q.put(new Integer(0)); + assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, MILLISECONDS)); + assertTrue(q.offer(new Integer(0), LONG_DELAY_MS, MILLISECONDS)); + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + t.interrupt(); + t.join(); } /** * take retrieves elements in priority order */ - public void testTake() { - try { - PriorityBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.take()).intValue()); - } - } catch (InterruptedException e){ - unexpectedException(); - } + public void testTake() throws InterruptedException { + PriorityBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.take()); + } } /** * take blocks interruptibly when empty */ - public void testTakeFromEmpty() { + public void testTakeFromEmpty() throws InterruptedException { final PriorityBlockingQueue q = new PriorityBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.take(); - threadShouldThrow(); - } catch (InterruptedException success){ } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + q.take(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * Take removes existing elements until empty, then blocks interruptibly */ - public void testBlockingTake() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - PriorityBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - threadAssertEquals(i, ((Integer)q.take()).intValue()); - } - q.take(); - threadShouldThrow(); - } catch (InterruptedException success){ - } - }}); + public void testBlockingTake() throws InterruptedException { + final PriorityBlockingQueue q = populatedQueue(SIZE); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.take()); + } + try { + q.take(); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } @@ -455,7 +392,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { public void testPoll() { PriorityBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.poll()).intValue()); + assertEquals(i, q.poll()); } assertNull(q.poll()); } @@ -463,86 +400,70 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { /** * timed pool with zero timeout succeeds when non-empty, else times out */ - public void testTimedPoll0() { - try { - PriorityBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue()); - } - assertNull(q.poll(0, TimeUnit.MILLISECONDS)); - } catch (InterruptedException e){ - unexpectedException(); - } + public void testTimedPoll0() throws InterruptedException { + PriorityBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(0, MILLISECONDS)); + } + assertNull(q.poll(0, MILLISECONDS)); } /** * timed pool with nonzero timeout succeeds when non-empty, else times out */ - public void testTimedPoll() { - try { - PriorityBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue()); - } - assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (InterruptedException e){ - unexpectedException(); - } + public void testTimedPoll() throws InterruptedException { + PriorityBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS)); + } + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); } /** * Interrupted timed poll throws InterruptedException instead of * returning timeout status */ - public void testInterruptedTimedPoll() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - PriorityBlockingQueue q = populatedQueue(SIZE); - for (int i = 0; i < SIZE; ++i) { - threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue()); - } - threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (InterruptedException success){ - } - }}); + public void testInterruptedTimedPoll() throws InterruptedException { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + PriorityBlockingQueue q = populatedQueue(SIZE); + for (int i = 0; i < SIZE; ++i) { + assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS)); + } + try { + q.poll(SMALL_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * timed poll before a delayed offer fails; after offer succeeds; * on interruption throws */ - public void testTimedPollWithOffer() { + public void testTimedPollWithOffer() throws InterruptedException { final PriorityBlockingQueue q = new PriorityBlockingQueue(2); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch (InterruptedException success) { } - } - }); - try { - t.start(); - Thread.sleep(SMALL_DELAY_MS); - assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); + assertSame(zero, q.poll(MEDIUM_DELAY_MS, MILLISECONDS)); + try { + q.poll(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS)); + t.interrupt(); + t.join(); + } /** @@ -551,10 +472,10 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { public void testPeek() { PriorityBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.peek()).intValue()); - q.poll(); + assertEquals(i, q.peek()); + assertEquals(i, q.poll()); assertTrue(q.peek() == null || - i != ((Integer)q.peek()).intValue()); + !q.peek().equals(i)); } assertNull(q.peek()); } @@ -565,14 +486,13 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { public void testElement() { PriorityBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.element()).intValue()); - q.poll(); + assertEquals(i, q.element()); + assertEquals(i, q.poll()); } try { q.element(); shouldThrow(); - } - catch (NoSuchElementException success) {} + } catch (NoSuchElementException success) {} } /** @@ -581,13 +501,12 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { public void testRemove() { PriorityBlockingQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.remove()).intValue()); + assertEquals(i, q.remove()); } try { q.remove(); shouldThrow(); - } catch (NoSuchElementException success){ - } + } catch (NoSuchElementException success) {} } /** @@ -604,7 +523,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { } assertTrue(q.isEmpty()); } - + /** * contains(x) reports true when elements added but not yet removed */ @@ -684,56 +603,48 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { /** * toArray contains all elements */ - public void testToArray() { + public void testToArray() throws InterruptedException { PriorityBlockingQueue q = populatedQueue(SIZE); Object[] o = q.toArray(); Arrays.sort(o); - try { - for(int i = 0; i < o.length; i++) + for (int i = 0; i < o.length; i++) assertEquals(o[i], q.take()); - } catch (InterruptedException e){ - unexpectedException(); - } } /** * toArray(a) contains all elements */ - public void testToArray2() { + public void testToArray2() throws InterruptedException { PriorityBlockingQueue q = populatedQueue(SIZE); Integer[] ints = new Integer[SIZE]; ints = (Integer[])q.toArray(ints); Arrays.sort(ints); - try { - for(int i = 0; i < ints.length; i++) - assertEquals(ints[i], q.take()); - } catch (InterruptedException e){ - unexpectedException(); - } + for (int i = 0; i < ints.length; i++) + assertEquals(ints[i], q.take()); } /** * toArray(null) throws NPE */ public void testToArray_BadArg() { + PriorityBlockingQueue q = populatedQueue(SIZE); try { - PriorityBlockingQueue q = populatedQueue(SIZE); Object o[] = q.toArray(null); shouldThrow(); - } catch(NullPointerException success){} + } catch (NullPointerException success) {} } /** * toArray with incompatible array type throws CCE */ public void testToArray1_BadArg() { + PriorityBlockingQueue q = populatedQueue(SIZE); try { - PriorityBlockingQueue q = populatedQueue(SIZE); - Object o[] = q.toArray(new String[10] ); + Object o[] = q.toArray(new String[10]); shouldThrow(); - } catch(ArrayStoreException success){} + } catch (ArrayStoreException success) {} } - + /** * iterator iterates through all elements */ @@ -741,7 +652,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { PriorityBlockingQueue q = populatedQueue(SIZE); int i = 0; Iterator it = q.iterator(); - while(it.hasNext()) { + while (it.hasNext()) { assertTrue(q.contains(it.next())); ++i; } @@ -777,7 +688,7 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { for (int i = 0; i < SIZE; ++i) { assertTrue(s.indexOf(String.valueOf(i)) >= 0); } - } + } /** * offer transfers elements across Executor tasks @@ -785,90 +696,72 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { public void testPollInExecutor() { final PriorityBlockingQueue q = new PriorityBlockingQueue(2); ExecutorService executor = Executors.newFixedThreadPool(2); - executor.execute(new Runnable() { - public void run() { - threadAssertNull(q.poll()); - try { - threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(q.isEmpty()); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll()); + assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS)); + assertTrue(q.isEmpty()); + }}); + + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); + q.put(one); + }}); - executor.execute(new Runnable() { - public void run() { - try { - Thread.sleep(SMALL_DELAY_MS); - q.put(new Integer(1)); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); - joinPool(executor); } /** - * A deserialized serialized queue has same elements + * A deserialized serialized queue has same elements */ - public void testSerialization() { + public void testSerialization() throws Exception { PriorityBlockingQueue q = populatedQueue(SIZE); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(q); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - PriorityBlockingQueue r = (PriorityBlockingQueue)in.readObject(); - assertEquals(q.size(), r.size()); - while (!q.isEmpty()) - assertEquals(q.remove(), r.remove()); - } catch(Exception e){ - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + PriorityBlockingQueue r = (PriorityBlockingQueue)in.readObject(); + assertEquals(q.size(), r.size()); + while (!q.isEmpty()) + assertEquals(q.remove(), r.remove()); } /** * drainTo(null) throws NPE - */ + */ public void testDrainToNull() { PriorityBlockingQueue q = populatedQueue(SIZE); try { q.drainTo(null); shouldThrow(); - } catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * drainTo(this) throws IAE - */ + */ public void testDrainToSelf() { PriorityBlockingQueue q = populatedQueue(SIZE); try { q.drainTo(q); shouldThrow(); - } catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } /** * drainTo(c) empties queue into another collection c - */ + */ public void testDrainTo() { PriorityBlockingQueue q = populatedQueue(SIZE); ArrayList l = new ArrayList(); q.drainTo(l); assertEquals(q.size(), 0); assertEquals(l.size(), SIZE); - for (int i = 0; i < SIZE; ++i) + for (int i = 0; i < SIZE; ++i) assertEquals(l.get(i), new Integer(i)); q.add(zero); q.add(one); @@ -879,76 +772,69 @@ public class PriorityBlockingQueueTest extends JSR166TestCase { q.drainTo(l); assertEquals(q.size(), 0); assertEquals(l.size(), 2); - for (int i = 0; i < 2; ++i) + for (int i = 0; i < 2; ++i) assertEquals(l.get(i), new Integer(i)); } /** * drainTo empties queue - */ - public void testDrainToWithActivePut() { + */ + public void testDrainToWithActivePut() throws InterruptedException { final PriorityBlockingQueue q = populatedQueue(SIZE); - Thread t = new Thread(new Runnable() { - public void run() { - q.put(new Integer(SIZE+1)); - } - }); - try { - t.start(); - ArrayList l = new ArrayList(); - q.drainTo(l); - assertTrue(l.size() >= SIZE); - for (int i = 0; i < SIZE; ++i) - assertEquals(l.get(i), new Integer(i)); - t.join(); - assertTrue(q.size() + l.size() >= SIZE); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + q.put(new Integer(SIZE+1)); + }}); + + t.start(); + ArrayList l = new ArrayList(); + q.drainTo(l); + assertTrue(l.size() >= SIZE); + for (int i = 0; i < SIZE; ++i) + assertEquals(l.get(i), new Integer(i)); + t.join(); + assertTrue(q.size() + l.size() >= SIZE); } /** * drainTo(null, n) throws NPE - */ + */ public void testDrainToNullN() { PriorityBlockingQueue q = populatedQueue(SIZE); try { q.drainTo(null, 0); shouldThrow(); - } catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * drainTo(this, n) throws IAE - */ + */ public void testDrainToSelfN() { PriorityBlockingQueue q = populatedQueue(SIZE); try { q.drainTo(q, 0); shouldThrow(); - } catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } /** * drainTo(c, n) empties first max {n, size} elements of queue into c - */ + */ public void testDrainToN() { PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2); for (int i = 0; i < SIZE + 2; ++i) { - for(int j = 0; j < SIZE; j++) + for (int j = 0; j < SIZE; j++) assertTrue(q.offer(new Integer(j))); ArrayList l = new ArrayList(); q.drainTo(l, i); int k = (i < SIZE)? i : SIZE; assertEquals(l.size(), k); assertEquals(q.size(), SIZE-k); - for (int j = 0; j < k; ++j) + for (int j = 0; j < k; ++j) assertEquals(l.get(j), new Integer(j)); while (q.poll() != null) ; } } - } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/PriorityQueueTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/PriorityQueueTest.java index 3d3c1be..12ddef4 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/PriorityQueueTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/PriorityQueueTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; @@ -18,13 +18,9 @@ public class PriorityQueueTest extends JSR166TestCase { return new TestSuite(PriorityQueueTest.class); } - static class MyReverseComparator implements Comparator { + static class MyReverseComparator implements Comparator { public int compare(Object x, Object y) { - int i = ((Integer)x).intValue(); - int j = ((Integer)y).intValue(); - if (i < j) return 1; - if (i > j) return -1; - return 0; + return ((Comparable)y).compareTo(x); } } @@ -35,15 +31,15 @@ public class PriorityQueueTest extends JSR166TestCase { private PriorityQueue populatedQueue(int n) { PriorityQueue q = new PriorityQueue(n); assertTrue(q.isEmpty()); - for(int i = n-1; i >= 0; i-=2) + for (int i = n-1; i >= 0; i-=2) assertTrue(q.offer(new Integer(i))); - for(int i = (n & 1); i < n; i+=2) + for (int i = (n & 1); i < n; i+=2) assertTrue(q.offer(new Integer(i))); assertFalse(q.isEmpty()); assertEquals(n, q.size()); return q; } - + /** * A new queue has unbounded capacity */ @@ -52,14 +48,13 @@ public class PriorityQueueTest extends JSR166TestCase { } /** - * Constructor throws IAE if capacity argument nonpositive + * Constructor throws IAE if capacity argument nonpositive */ public void testConstructor2() { try { PriorityQueue q = new PriorityQueue(0); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } /** @@ -69,8 +64,7 @@ public class PriorityQueueTest extends JSR166TestCase { try { PriorityQueue q = new PriorityQueue((Collection)null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -81,8 +75,7 @@ public class PriorityQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; PriorityQueue q = new PriorityQueue(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -95,41 +88,34 @@ public class PriorityQueueTest extends JSR166TestCase { ints[i] = new Integer(i); PriorityQueue q = new PriorityQueue(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * Queue contains all elements of collection used to initialize */ public void testConstructor6() { - try { - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - PriorityQueue q = new PriorityQueue(Arrays.asList(ints)); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); - } - finally {} + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + PriorityQueue q = new PriorityQueue(Arrays.asList(ints)); + for (int i = 0; i < SIZE; ++i) + assertEquals(ints[i], q.poll()); } /** * The comparator used in constructor is used */ public void testConstructor7() { - try { - MyReverseComparator cmp = new MyReverseComparator(); - PriorityQueue q = new PriorityQueue(SIZE, cmp); - assertEquals(cmp, q.comparator()); - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - q.addAll(Arrays.asList(ints)); - for (int i = SIZE-1; i >= 0; --i) - assertEquals(ints[i], q.poll()); - } - finally {} + MyReverseComparator cmp = new MyReverseComparator(); + PriorityQueue q = new PriorityQueue(SIZE, cmp); + assertEquals(cmp, q.comparator()); + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(i); + q.addAll(Arrays.asList(ints)); + for (int i = SIZE-1; i >= 0; --i) + assertEquals(ints[i], q.poll()); } /** @@ -169,7 +155,7 @@ public class PriorityQueueTest extends JSR166TestCase { PriorityQueue q = new PriorityQueue(1); q.offer(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -180,7 +166,7 @@ public class PriorityQueueTest extends JSR166TestCase { PriorityQueue q = new PriorityQueue(1); q.add(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -202,8 +188,7 @@ public class PriorityQueueTest extends JSR166TestCase { q.offer(new Object()); q.offer(new Object()); shouldThrow(); - } - catch(ClassCastException success) {} + } catch (ClassCastException success) {} } /** @@ -225,8 +210,7 @@ public class PriorityQueueTest extends JSR166TestCase { PriorityQueue q = new PriorityQueue(1); q.addAll(null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll of a collection with null elements throws NPE @@ -237,8 +221,7 @@ public class PriorityQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll of a collection with any null elements throws NPE after @@ -252,26 +235,22 @@ public class PriorityQueueTest extends JSR166TestCase { ints[i] = new Integer(i); q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * Queue contains all elements of successful addAll */ public void testAddAll5() { - try { - Integer[] empty = new Integer[0]; - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(SIZE-1-i); - PriorityQueue q = new PriorityQueue(SIZE); - assertFalse(q.addAll(Arrays.asList(empty))); - assertTrue(q.addAll(Arrays.asList(ints))); - for (int i = 0; i < SIZE; ++i) - assertEquals(new Integer(i), q.poll()); - } - finally {} + Integer[] empty = new Integer[0]; + Integer[] ints = new Integer[SIZE]; + for (int i = 0; i < SIZE; ++i) + ints[i] = new Integer(SIZE-1-i); + PriorityQueue q = new PriorityQueue(SIZE); + assertFalse(q.addAll(Arrays.asList(empty))); + assertTrue(q.addAll(Arrays.asList(ints))); + for (int i = 0; i < SIZE; ++i) + assertEquals(new Integer(i), q.poll()); } /** @@ -280,7 +259,7 @@ public class PriorityQueueTest extends JSR166TestCase { public void testPoll() { PriorityQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.poll()).intValue()); + assertEquals(i, q.poll()); } assertNull(q.poll()); } @@ -291,10 +270,10 @@ public class PriorityQueueTest extends JSR166TestCase { public void testPeek() { PriorityQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.peek()).intValue()); - q.poll(); + assertEquals(i, q.peek()); + assertEquals(i, q.poll()); assertTrue(q.peek() == null || - i != ((Integer)q.peek()).intValue()); + !q.peek().equals(i)); } assertNull(q.peek()); } @@ -305,14 +284,13 @@ public class PriorityQueueTest extends JSR166TestCase { public void testElement() { PriorityQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.element()).intValue()); - q.poll(); + assertEquals(i, q.element()); + assertEquals(i, q.poll()); } try { q.element(); shouldThrow(); - } - catch (NoSuchElementException success) {} + } catch (NoSuchElementException success) {} } /** @@ -321,13 +299,12 @@ public class PriorityQueueTest extends JSR166TestCase { public void testRemove() { PriorityQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, ((Integer)q.remove()).intValue()); + assertEquals(i, q.remove()); } try { q.remove(); shouldThrow(); - } catch (NoSuchElementException success){ - } + } catch (NoSuchElementException success) {} } /** @@ -344,7 +321,7 @@ public class PriorityQueueTest extends JSR166TestCase { } assertTrue(q.isEmpty()); } - + /** * contains(x) reports true when elements added but not yet removed */ @@ -427,7 +404,7 @@ public class PriorityQueueTest extends JSR166TestCase { PriorityQueue q = populatedQueue(SIZE); Object[] o = q.toArray(); Arrays.sort(o); - for(int i = 0; i < o.length; i++) + for (int i = 0; i < o.length; i++) assertEquals(o[i], q.poll()); } @@ -439,10 +416,10 @@ public class PriorityQueueTest extends JSR166TestCase { Integer[] ints = new Integer[SIZE]; ints = (Integer[])q.toArray(ints); Arrays.sort(ints); - for(int i = 0; i < ints.length; i++) + for (int i = 0; i < ints.length; i++) assertEquals(ints[i], q.poll()); } - + /** * iterator iterates through all elements */ @@ -450,7 +427,7 @@ public class PriorityQueueTest extends JSR166TestCase { PriorityQueue q = populatedQueue(SIZE); int i = 0; Iterator it = q.iterator(); - while(it.hasNext()) { + while (it.hasNext()) { assertTrue(q.contains(it.next())); ++i; } @@ -486,27 +463,23 @@ public class PriorityQueueTest extends JSR166TestCase { for (int i = 0; i < SIZE; ++i) { assertTrue(s.indexOf(String.valueOf(i)) >= 0); } - } + } /** - * A deserialized serialized queue has same elements + * A deserialized serialized queue has same elements */ - public void testSerialization() { + public void testSerialization() throws Exception { PriorityQueue q = populatedQueue(SIZE); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(q); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - PriorityQueue r = (PriorityQueue)in.readObject(); - assertEquals(q.size(), r.size()); - while (!q.isEmpty()) - assertEquals(q.remove(), r.remove()); - } catch(Exception e){ - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + PriorityQueue r = (PriorityQueue)in.readObject(); + assertEquals(q.size(), r.size()); + while (!q.isEmpty()) + assertEquals(q.remove(), r.remove()); } } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ReentrantLockTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ReentrantLockTest.java index 8372251..d6b434e 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ReentrantLockTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ReentrantLockTest.java @@ -2,15 +2,16 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.locks.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.util.*; import java.io.*; @@ -22,13 +23,11 @@ public class ReentrantLockTest extends JSR166TestCase { /** * A runnable calling lockInterruptibly */ - class InterruptibleLockRunnable implements Runnable { + class InterruptibleLockRunnable extends CheckedRunnable { final ReentrantLock lock; InterruptibleLockRunnable(ReentrantLock l) { lock = l; } - public void run() { - try { - lock.lockInterruptibly(); - } catch(InterruptedException success){} + public void realRun() throws InterruptedException { + lock.lockInterruptibly(); } } @@ -37,14 +36,11 @@ public class ReentrantLockTest extends JSR166TestCase { * A runnable calling lockInterruptibly that expects to be * interrupted */ - class InterruptedLockRunnable implements Runnable { + class InterruptedLockRunnable extends CheckedInterruptedRunnable { final ReentrantLock lock; InterruptedLockRunnable(ReentrantLock l) { lock = l; } - public void run() { - try { - lock.lockInterruptibly(); - threadShouldThrow(); - } catch(InterruptedException success){} + public void realRun() throws InterruptedException { + lock.lockInterruptibly(); } } @@ -59,18 +55,15 @@ public class ReentrantLockTest extends JSR166TestCase { public Collection<Thread> getWaitingThreads(Condition c) { return super.getWaitingThreads(c); } - - } /** * Constructor sets given fairness */ public void testConstructor() { - ReentrantLock rl = new ReentrantLock(); - assertFalse(rl.isFair()); - ReentrantLock r2 = new ReentrantLock(true); - assertTrue(r2.isFair()); + assertFalse(new ReentrantLock().isFair()); + assertFalse(new ReentrantLock(false).isFair()); + assertTrue(new ReentrantLock(true).isFair()); } /** @@ -81,6 +74,7 @@ public class ReentrantLockTest extends JSR166TestCase { rl.lock(); assertTrue(rl.isLocked()); rl.unlock(); + assertFalse(rl.isLocked()); } /** @@ -101,8 +95,7 @@ public class ReentrantLockTest extends JSR166TestCase { try { rl.unlock(); shouldThrow(); - - } catch(IllegalMonitorStateException success){} + } catch (IllegalMonitorStateException success) {} } /** @@ -119,88 +112,76 @@ public class ReentrantLockTest extends JSR166TestCase { /** * hasQueuedThreads reports whether there are waiting threads */ - public void testhasQueuedThreads() { + public void testhasQueuedThreads() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertFalse(lock.hasQueuedThreads()); - lock.lock(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - lock.unlock(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(lock.hasQueuedThreads()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } + assertFalse(lock.hasQueuedThreads()); + lock.lock(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.hasQueuedThreads()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.hasQueuedThreads()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.hasQueuedThreads()); + lock.unlock(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(lock.hasQueuedThreads()); + t1.join(); + t2.join(); } /** * getQueueLength reports number of waiting threads */ - public void testGetQueueLength() { + public void testGetQueueLength() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertEquals(0, lock.getQueueLength()); - lock.lock(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, lock.getQueueLength()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(2, lock.getQueueLength()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, lock.getQueueLength()); - lock.unlock(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(0, lock.getQueueLength()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } + assertEquals(0, lock.getQueueLength()); + lock.lock(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, lock.getQueueLength()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(2, lock.getQueueLength()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, lock.getQueueLength()); + lock.unlock(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(0, lock.getQueueLength()); + t1.join(); + t2.join(); } /** * getQueueLength reports number of waiting threads */ - public void testGetQueueLength_fair() { + public void testGetQueueLength_fair() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(true); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertEquals(0, lock.getQueueLength()); - lock.lock(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, lock.getQueueLength()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(2, lock.getQueueLength()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, lock.getQueueLength()); - lock.unlock(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(0, lock.getQueueLength()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } + assertEquals(0, lock.getQueueLength()); + lock.lock(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, lock.getQueueLength()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(2, lock.getQueueLength()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, lock.getQueueLength()); + lock.unlock(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(0, lock.getQueueLength()); + t1.join(); + t2.join(); } /** @@ -211,143 +192,117 @@ public class ReentrantLockTest extends JSR166TestCase { try { sync.hasQueuedThread(null); shouldThrow(); - } catch (NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * hasQueuedThread reports whether a thread is queued. */ - public void testHasQueuedThread() { + public void testHasQueuedThread() throws InterruptedException { final ReentrantLock sync = new ReentrantLock(); Thread t1 = new Thread(new InterruptedLockRunnable(sync)); Thread t2 = new Thread(new InterruptibleLockRunnable(sync)); - try { - assertFalse(sync.hasQueuedThread(t1)); - assertFalse(sync.hasQueuedThread(t2)); - sync.lock(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasQueuedThread(t1)); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasQueuedThread(t1)); - assertTrue(sync.hasQueuedThread(t2)); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.hasQueuedThread(t1)); - assertTrue(sync.hasQueuedThread(t2)); - sync.unlock(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.hasQueuedThread(t1)); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.hasQueuedThread(t2)); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } + assertFalse(sync.hasQueuedThread(t1)); + assertFalse(sync.hasQueuedThread(t2)); + sync.lock(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThread(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThread(t1)); + assertTrue(sync.hasQueuedThread(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.hasQueuedThread(t1)); + assertTrue(sync.hasQueuedThread(t2)); + sync.unlock(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.hasQueuedThread(t1)); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.hasQueuedThread(t2)); + t1.join(); + t2.join(); } /** * getQueuedThreads includes waiting threads */ - public void testGetQueuedThreads() { + public void testGetQueuedThreads() throws InterruptedException { final PublicReentrantLock lock = new PublicReentrantLock(); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertTrue(lock.getQueuedThreads().isEmpty()); - lock.lock(); - assertTrue(lock.getQueuedThreads().isEmpty()); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.getQueuedThreads().contains(t1)); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.getQueuedThreads().contains(t1)); - assertTrue(lock.getQueuedThreads().contains(t2)); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(lock.getQueuedThreads().contains(t1)); - assertTrue(lock.getQueuedThreads().contains(t2)); - lock.unlock(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.getQueuedThreads().isEmpty()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } + assertTrue(lock.getQueuedThreads().isEmpty()); + lock.lock(); + assertTrue(lock.getQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.getQueuedThreads().contains(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.getQueuedThreads().contains(t1)); + assertTrue(lock.getQueuedThreads().contains(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(lock.getQueuedThreads().contains(t1)); + assertTrue(lock.getQueuedThreads().contains(t2)); + lock.unlock(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.getQueuedThreads().isEmpty()); + t1.join(); + t2.join(); } /** * timed tryLock is interruptible. */ - public void testInterruptedException2() { + public void testInterruptedException2() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); lock.lock(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(InterruptedException success){} - } - }); - try { - t.start(); - t.interrupt(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.tryLock(MEDIUM_DELAY_MS,MILLISECONDS); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * TryLock on a locked lock fails */ - public void testTryLockWhenLocked() { + public void testTryLockWhenLocked() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); lock.lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertFalse(lock.tryLock()); - } - }); - try { - t.start(); - t.join(); - lock.unlock(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + threadAssertFalse(lock.tryLock()); + }}); + + t.start(); + t.join(); + lock.unlock(); } /** * Timed tryLock on a locked lock times out */ - public void testTryLock_Timeout() { + public void testTryLock_Timeout() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); lock.lock(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS)); - } catch (Exception ex) { - threadUnexpectedException(); - } - } - }); - try { - t.start(); - t.join(); - lock.unlock(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + threadAssertFalse(lock.tryLock(1, MILLISECONDS)); + }}); + + t.start(); + t.join(); + lock.unlock(); } /** @@ -355,13 +310,13 @@ public class ReentrantLockTest extends JSR166TestCase { */ public void testGetHoldCount() { ReentrantLock lock = new ReentrantLock(); - for(int i = 1; i <= SIZE; i++) { + for (int i = 1; i <= SIZE; i++) { lock.lock(); - assertEquals(i,lock.getHoldCount()); + assertEquals(i, lock.getHoldCount()); } - for(int i = SIZE; i > 0; i--) { + for (int i = SIZE; i > 0; i--) { lock.unlock(); - assertEquals(i-1,lock.getHoldCount()); + assertEquals(i-1, lock.getHoldCount()); } } @@ -369,92 +324,67 @@ public class ReentrantLockTest extends JSR166TestCase { /** * isLocked is true when locked and false when not */ - public void testIsLocked() { + public void testIsLocked() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); lock.lock(); assertTrue(lock.isLocked()); lock.unlock(); assertFalse(lock.isLocked()); - Thread t = new Thread(new Runnable() { - public void run() { - lock.lock(); - try { - Thread.sleep(SMALL_DELAY_MS); - } - catch(Exception e) { - threadUnexpectedException(); - } - lock.unlock(); - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.isLocked()); - t.join(); - assertFalse(lock.isLocked()); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + Thread.sleep(SMALL_DELAY_MS); + lock.unlock(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.isLocked()); + t.join(); + assertFalse(lock.isLocked()); } /** * lockInterruptibly is interruptible. */ - public void testLockInterruptibly1() { + public void testLockInterruptibly1() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); lock.lock(); Thread t = new Thread(new InterruptedLockRunnable(lock)); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - lock.unlock(); - t.join(); - } catch(Exception e){ - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + lock.unlock(); + t.join(); } /** * lockInterruptibly succeeds when unlocked, else is interruptible */ - public void testLockInterruptibly2() { + public void testLockInterruptibly2() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); - try { - lock.lockInterruptibly(); - } catch(Exception e) { - unexpectedException(); - } + lock.lockInterruptibly(); Thread t = new Thread(new InterruptedLockRunnable(lock)); - try { - t.start(); - t.interrupt(); - assertTrue(lock.isLocked()); - assertTrue(lock.isHeldByCurrentThread()); - t.join(); - } catch(Exception e){ - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + assertTrue(lock.isLocked()); + assertTrue(lock.isHeldByCurrentThread()); + t.join(); } /** * Calling await without holding lock throws IllegalMonitorStateException */ - public void testAwait_IllegalMonitor() { + public void testAwait_IllegalMonitor() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); try { c.await(); shouldThrow(); - } - catch (IllegalMonitorStateException success) { - } - catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } /** @@ -466,95 +396,64 @@ public class ReentrantLockTest extends JSR166TestCase { try { c.signal(); shouldThrow(); - } - catch (IllegalMonitorStateException success) { - } - catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } /** * awaitNanos without a signal times out */ - public void testAwaitNanos_Timeout() { + public void testAwaitNanos_Timeout() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - try { - lock.lock(); - long t = c.awaitNanos(100); - assertTrue(t <= 0); - lock.unlock(); - } - catch (Exception ex) { - unexpectedException(); - } + lock.lock(); + long t = c.awaitNanos(100); + assertTrue(t <= 0); + lock.unlock(); } /** * timed await without a signal times out */ - public void testAwait_Timeout() { + public void testAwait_Timeout() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - try { - lock.lock(); - c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - lock.unlock(); - } - catch (Exception ex) { - unexpectedException(); - } + lock.lock(); + assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS)); + lock.unlock(); } /** * awaitUntil without a signal times out */ - public void testAwaitUntil_Timeout() { + public void testAwaitUntil_Timeout() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - try { - lock.lock(); - java.util.Date d = new java.util.Date(); - c.awaitUntil(new java.util.Date(d.getTime() + 10)); - lock.unlock(); - } - catch (Exception ex) { - unexpectedException(); - } + lock.lock(); + java.util.Date d = new java.util.Date(); + assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10))); + lock.unlock(); } /** * await returns when signalled */ - public void testAwait() { + public void testAwait() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - c.await(); - lock.unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + c.await(); + lock.unlock(); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.lock(); - c.signal(); - lock.unlock(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.lock(); + c.signal(); + lock.unlock(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** @@ -565,10 +464,7 @@ public class ReentrantLockTest extends JSR166TestCase { try { lock.hasWaiters(null); shouldThrow(); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (NullPointerException success) {} } /** @@ -579,10 +475,7 @@ public class ReentrantLockTest extends JSR166TestCase { try { lock.getWaitQueueLength(null); shouldThrow(); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (NullPointerException success) {} } @@ -594,10 +487,7 @@ public class ReentrantLockTest extends JSR166TestCase { try { lock.getWaitingThreads(null); shouldThrow(); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (NullPointerException success) {} } @@ -606,15 +496,12 @@ public class ReentrantLockTest extends JSR166TestCase { */ public void testHasWaitersIAE() { final ReentrantLock lock = new ReentrantLock(); - final Condition c = (lock.newCondition()); + final Condition c = lock.newCondition(); final ReentrantLock lock2 = new ReentrantLock(); try { lock2.hasWaiters(c); shouldThrow(); - } catch (IllegalArgumentException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalArgumentException success) {} } /** @@ -622,14 +509,11 @@ public class ReentrantLockTest extends JSR166TestCase { */ public void testHasWaitersIMSE() { final ReentrantLock lock = new ReentrantLock(); - final Condition c = (lock.newCondition()); + final Condition c = lock.newCondition(); try { lock.hasWaiters(c); shouldThrow(); - } catch (IllegalMonitorStateException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } @@ -638,15 +522,12 @@ public class ReentrantLockTest extends JSR166TestCase { */ public void testGetWaitQueueLengthIAE() { final ReentrantLock lock = new ReentrantLock(); - final Condition c = (lock.newCondition()); + final Condition c = lock.newCondition(); final ReentrantLock lock2 = new ReentrantLock(); try { lock2.getWaitQueueLength(c); shouldThrow(); - } catch (IllegalArgumentException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalArgumentException success) {} } /** @@ -654,14 +535,11 @@ public class ReentrantLockTest extends JSR166TestCase { */ public void testGetWaitQueueLengthIMSE() { final ReentrantLock lock = new ReentrantLock(); - final Condition c = (lock.newCondition()); + final Condition c = lock.newCondition(); try { lock.getWaitQueueLength(c); shouldThrow(); - } catch (IllegalMonitorStateException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } @@ -670,15 +548,12 @@ public class ReentrantLockTest extends JSR166TestCase { */ public void testGetWaitingThreadsIAE() { final PublicReentrantLock lock = new PublicReentrantLock(); - final Condition c = (lock.newCondition()); + final Condition c = lock.newCondition(); final PublicReentrantLock lock2 = new PublicReentrantLock(); try { lock2.getWaitingThreads(c); shouldThrow(); - } catch (IllegalArgumentException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalArgumentException success) {} } /** @@ -686,186 +561,137 @@ public class ReentrantLockTest extends JSR166TestCase { */ public void testGetWaitingThreadsIMSE() { final PublicReentrantLock lock = new PublicReentrantLock(); - final Condition c = (lock.newCondition()); + final Condition c = lock.newCondition(); try { lock.getWaitingThreads(c); shouldThrow(); - } catch (IllegalMonitorStateException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } - /** * hasWaiters returns true when a thread is waiting, else false */ - public void testHasWaiters() { + public void testHasWaiters() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - threadAssertFalse(lock.hasWaiters(c)); - threadAssertEquals(0, lock.getWaitQueueLength(c)); - c.await(); - lock.unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + threadAssertFalse(lock.hasWaiters(c)); + threadAssertEquals(0, lock.getWaitQueueLength(c)); + c.await(); + lock.unlock(); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.lock(); - assertTrue(lock.hasWaiters(c)); - assertEquals(1, lock.getWaitQueueLength(c)); - c.signal(); - lock.unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.lock(); - assertFalse(lock.hasWaiters(c)); - assertEquals(0, lock.getWaitQueueLength(c)); - lock.unlock(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.lock(); + assertTrue(lock.hasWaiters(c)); + assertEquals(1, lock.getWaitQueueLength(c)); + c.signal(); + lock.unlock(); + Thread.sleep(SHORT_DELAY_MS); + lock.lock(); + assertFalse(lock.hasWaiters(c)); + assertEquals(0, lock.getWaitQueueLength(c)); + lock.unlock(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * getWaitQueueLength returns number of waiting threads */ - public void testGetWaitQueueLength() { + public void testGetWaitQueueLength() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - threadAssertFalse(lock.hasWaiters(c)); - threadAssertEquals(0, lock.getWaitQueueLength(c)); - c.await(); - lock.unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - threadAssertTrue(lock.hasWaiters(c)); - threadAssertEquals(1, lock.getWaitQueueLength(c)); - c.await(); - lock.unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + threadAssertFalse(lock.hasWaiters(c)); + threadAssertEquals(0, lock.getWaitQueueLength(c)); + c.await(); + lock.unlock(); + }}); + + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + threadAssertTrue(lock.hasWaiters(c)); + threadAssertEquals(1, lock.getWaitQueueLength(c)); + c.await(); + lock.unlock(); + }}); - try { - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.lock(); - assertTrue(lock.hasWaiters(c)); - assertEquals(2, lock.getWaitQueueLength(c)); - c.signalAll(); - lock.unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.lock(); - assertFalse(lock.hasWaiters(c)); - assertEquals(0, lock.getWaitQueueLength(c)); - lock.unlock(); - t1.join(SHORT_DELAY_MS); - t2.join(SHORT_DELAY_MS); - assertFalse(t1.isAlive()); - assertFalse(t2.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.lock(); + assertTrue(lock.hasWaiters(c)); + assertEquals(2, lock.getWaitQueueLength(c)); + c.signalAll(); + lock.unlock(); + Thread.sleep(SHORT_DELAY_MS); + lock.lock(); + assertFalse(lock.hasWaiters(c)); + assertEquals(0, lock.getWaitQueueLength(c)); + lock.unlock(); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); } /** * getWaitingThreads returns only and all waiting threads */ - public void testGetWaitingThreads() { + public void testGetWaitingThreads() throws InterruptedException { final PublicReentrantLock lock = new PublicReentrantLock(); final Condition c = lock.newCondition(); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - threadAssertTrue(lock.getWaitingThreads(c).isEmpty()); - c.await(); - lock.unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - threadAssertFalse(lock.getWaitingThreads(c).isEmpty()); - c.await(); - lock.unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + threadAssertTrue(lock.getWaitingThreads(c).isEmpty()); + c.await(); + lock.unlock(); + }}); - try { - lock.lock(); - assertTrue(lock.getWaitingThreads(c).isEmpty()); - lock.unlock(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.lock(); - assertTrue(lock.hasWaiters(c)); - assertTrue(lock.getWaitingThreads(c).contains(t1)); - assertTrue(lock.getWaitingThreads(c).contains(t2)); - c.signalAll(); - lock.unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.lock(); - assertFalse(lock.hasWaiters(c)); - assertTrue(lock.getWaitingThreads(c).isEmpty()); - lock.unlock(); - t1.join(SHORT_DELAY_MS); - t2.join(SHORT_DELAY_MS); - assertFalse(t1.isAlive()); - assertFalse(t2.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + threadAssertFalse(lock.getWaitingThreads(c).isEmpty()); + c.await(); + lock.unlock(); + }}); + + lock.lock(); + assertTrue(lock.getWaitingThreads(c).isEmpty()); + lock.unlock(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.lock(); + assertTrue(lock.hasWaiters(c)); + assertTrue(lock.getWaitingThreads(c).contains(t1)); + assertTrue(lock.getWaitingThreads(c).contains(t2)); + c.signalAll(); + lock.unlock(); + Thread.sleep(SHORT_DELAY_MS); + lock.lock(); + assertFalse(lock.hasWaiters(c)); + assertTrue(lock.getWaitingThreads(c).isEmpty()); + lock.unlock(); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); } /** A helper class for uninterruptible wait tests */ - class UninterruptableThread extends Thread { + class UninterruptibleThread extends Thread { private ReentrantLock lock; private Condition c; @@ -873,7 +699,7 @@ public class ReentrantLockTest extends JSR166TestCase { public volatile boolean interrupted = false; public volatile boolean lockStarted = false; - public UninterruptableThread(ReentrantLock lock, Condition c) { + public UninterruptibleThread(ReentrantLock lock, Condition c) { this.lock = lock; this.c = c; } @@ -894,256 +720,180 @@ public class ReentrantLockTest extends JSR166TestCase { /** * awaitUninterruptibly doesn't abort on interrupt */ - public void testAwaitUninterruptibly() { + public void testAwaitUninterruptibly() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - UninterruptableThread thread = new UninterruptableThread(lock, c); + UninterruptibleThread thread = new UninterruptibleThread(lock, c); - try { - thread.start(); + thread.start(); - while (!thread.lockStarted) { - Thread.sleep(100); - } - - lock.lock(); - try { - thread.interrupt(); - thread.canAwake = true; - c.signal(); - } finally { - lock.unlock(); - } + while (!thread.lockStarted) { + Thread.sleep(100); + } - thread.join(); - assertTrue(thread.interrupted); - assertFalse(thread.isAlive()); - } catch (Exception ex) { - unexpectedException(); + lock.lock(); + try { + thread.interrupt(); + thread.canAwake = true; + c.signal(); + } finally { + lock.unlock(); } + + thread.join(); + assertTrue(thread.interrupted); + assertFalse(thread.isAlive()); } /** * await is interruptible */ - public void testAwait_Interrupt() { + public void testAwait_Interrupt() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - c.await(); - lock.unlock(); - threadShouldThrow(); - } - catch(InterruptedException success) { - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + c.await(); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * awaitNanos is interruptible */ - public void testAwaitNanos_Interrupt() { + public void testAwaitNanos_Interrupt() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - c.awaitNanos(1000 * 1000 * 1000); // 1 sec - lock.unlock(); - threadShouldThrow(); - } - catch(InterruptedException success) { - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * awaitUntil is interruptible */ - public void testAwaitUntil_Interrupt() { + public void testAwaitUntil_Interrupt() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - java.util.Date d = new java.util.Date(); - c.awaitUntil(new java.util.Date(d.getTime() + 10000)); - lock.unlock(); - threadShouldThrow(); - } - catch(InterruptedException success) { - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + java.util.Date d = new java.util.Date(); + c.awaitUntil(new java.util.Date(d.getTime() + 10000)); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * signalAll wakes up all threads */ - public void testSignalAll() { + public void testSignalAll() throws InterruptedException { final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - c.await(); - lock.unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - c.await(); - lock.unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + c.await(); + lock.unlock(); + }}); - try { - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.lock(); - c.signalAll(); - lock.unlock(); - t1.join(SHORT_DELAY_MS); - t2.join(SHORT_DELAY_MS); - assertFalse(t1.isAlive()); - assertFalse(t2.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + c.await(); + lock.unlock(); + }}); + + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.lock(); + c.signalAll(); + lock.unlock(); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); } /** * await after multiple reentrant locking preserves lock count */ - public void testAwaitLockCount() { - final ReentrantLock lock = new ReentrantLock(); + public void testAwaitLockCount() throws InterruptedException { + final ReentrantLock lock = new ReentrantLock(); final Condition c = lock.newCondition(); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - threadAssertEquals(1, lock.getHoldCount()); - c.await(); - threadAssertEquals(1, lock.getHoldCount()); - lock.unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - lock.lock(); - lock.lock(); - threadAssertEquals(2, lock.getHoldCount()); - c.await(); - threadAssertEquals(2, lock.getHoldCount()); - lock.unlock(); - lock.unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + threadAssertEquals(1, lock.getHoldCount()); + c.await(); + threadAssertEquals(1, lock.getHoldCount()); + lock.unlock(); + }}); + + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.lock(); + lock.lock(); + threadAssertEquals(2, lock.getHoldCount()); + c.await(); + threadAssertEquals(2, lock.getHoldCount()); + lock.unlock(); + lock.unlock(); + }}); - try { - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.lock(); - c.signalAll(); - lock.unlock(); - t1.join(SHORT_DELAY_MS); - t2.join(SHORT_DELAY_MS); - assertFalse(t1.isAlive()); - assertFalse(t2.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.lock(); + c.signalAll(); + lock.unlock(); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); } /** * A serialized lock deserializes as unlocked */ - public void testSerialization() { + public void testSerialization() throws Exception { ReentrantLock l = new ReentrantLock(); l.lock(); l.unlock(); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - ReentrantLock r = (ReentrantLock) in.readObject(); - r.lock(); - r.unlock(); - } catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = + new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); + + ByteArrayInputStream bin = + new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = + new ObjectInputStream(new BufferedInputStream(bin)); + ReentrantLock r = (ReentrantLock) in.readObject(); + r.lock(); + r.unlock(); } /** diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ReentrantReadWriteLockTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ReentrantReadWriteLockTest.java index 4191a13..eb20255 100644 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ReentrantReadWriteLockTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ReentrantReadWriteLockTest.java @@ -2,15 +2,16 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.locks.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.io.*; import java.util.*; @@ -22,13 +23,11 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { /** * A runnable calling lockInterruptibly */ - class InterruptibleLockRunnable implements Runnable { + class InterruptibleLockRunnable extends CheckedRunnable { final ReentrantReadWriteLock lock; InterruptibleLockRunnable(ReentrantReadWriteLock l) { lock = l; } - public void run() { - try { - lock.writeLock().lockInterruptibly(); - } catch(InterruptedException success){} + public void realRun() throws InterruptedException { + lock.writeLock().lockInterruptibly(); } } @@ -37,14 +36,11 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { * A runnable calling lockInterruptibly that expects to be * interrupted */ - class InterruptedLockRunnable implements Runnable { + class InterruptedLockRunnable extends CheckedInterruptedRunnable { final ReentrantReadWriteLock lock; InterruptedLockRunnable(ReentrantReadWriteLock l) { lock = l; } - public void run() { - try { - lock.writeLock().lockInterruptibly(); - threadShouldThrow(); - } catch(InterruptedException success){} + public void realRun() throws InterruptedException { + lock.writeLock().lockInterruptibly(); } } @@ -73,6 +69,10 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { assertTrue(r2.isFair()); assertFalse(r2.isWriteLocked()); assertEquals(0, r2.getReadLockCount()); + ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false); + assertFalse(r3.isFair()); + assertFalse(r3.isWriteLocked()); + assertEquals(0, r3.getReadLockCount()); } /** @@ -83,10 +83,12 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { rl.writeLock().lock(); assertTrue(rl.isWriteLocked()); assertTrue(rl.isWriteLockedByCurrentThread()); + assertTrue(rl.writeLock().isHeldByCurrentThread()); assertEquals(0, rl.getReadLockCount()); rl.writeLock().unlock(); assertFalse(rl.isWriteLocked()); assertFalse(rl.isWriteLockedByCurrentThread()); + assertFalse(rl.writeLock().isHeldByCurrentThread()); assertEquals(0, rl.getReadLockCount()); rl.readLock().lock(); assertFalse(rl.isWriteLocked()); @@ -107,10 +109,12 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { rl.writeLock().lock(); assertTrue(rl.isWriteLocked()); assertTrue(rl.isWriteLockedByCurrentThread()); + assertTrue(rl.writeLock().isHeldByCurrentThread()); assertEquals(0, rl.getReadLockCount()); rl.writeLock().unlock(); assertFalse(rl.isWriteLocked()); assertFalse(rl.isWriteLockedByCurrentThread()); + assertFalse(rl.writeLock().isHeldByCurrentThread()); assertEquals(0, rl.getReadLockCount()); rl.readLock().lock(); assertFalse(rl.isWriteLocked()); @@ -126,15 +130,45 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { * getWriteHoldCount returns number of recursive holds */ public void testGetWriteHoldCount() { - ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - for(int i = 1; i <= SIZE; i++) { - lock.writeLock().lock(); - assertEquals(i,lock.getWriteHoldCount()); - } - for(int i = SIZE; i > 0; i--) { - lock.writeLock().unlock(); - assertEquals(i-1,lock.getWriteHoldCount()); - } + ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + for (int i = 1; i <= SIZE; i++) { + lock.writeLock().lock(); + assertEquals(i,lock.getWriteHoldCount()); + } + for (int i = SIZE; i > 0; i--) { + lock.writeLock().unlock(); + assertEquals(i-1,lock.getWriteHoldCount()); + } + } + + /** + * WriteLock.getHoldCount returns number of recursive holds + */ + public void testGetHoldCount() { + ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + for (int i = 1; i <= SIZE; i++) { + lock.writeLock().lock(); + assertEquals(i,lock.writeLock().getHoldCount()); + } + for (int i = SIZE; i > 0; i--) { + lock.writeLock().unlock(); + assertEquals(i-1,lock.writeLock().getHoldCount()); + } + } + + /** + * getReadHoldCount returns number of recursive holds + */ + public void testGetReadHoldCount() { + ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + for (int i = 1; i <= SIZE; i++) { + lock.readLock().lock(); + assertEquals(i,lock.getReadHoldCount()); + } + for (int i = SIZE; i > 0; i--) { + lock.readLock().unlock(); + assertEquals(i-1,lock.getReadHoldCount()); + } } @@ -146,245 +180,196 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { try { rl.writeLock().unlock(); shouldThrow(); - } catch(IllegalMonitorStateException success){} + } catch (IllegalMonitorStateException success) {} } /** * write-lockInterruptibly is interruptible */ - public void testWriteLockInterruptibly_Interrupted() { + public void testWriteLockInterruptibly_Interrupted() throws Exception { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lockInterruptibly(); - lock.writeLock().unlock(); - lock.writeLock().lockInterruptibly(); - lock.writeLock().unlock(); - } catch(InterruptedException success){} - } - }); - try { - lock.writeLock().lock(); - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().unlock(); - t.join(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lockInterruptibly(); + lock.writeLock().unlock(); + lock.writeLock().lockInterruptibly(); + lock.writeLock().unlock(); + }}); + + lock.writeLock().lock(); + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().unlock(); + t.join(); } /** * timed write-tryLock is interruptible */ - public void testWriteTryLock_Interrupted() { + public void testWriteTryLock_Interrupted() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS); - } catch(InterruptedException success){} - } - }); - try { - t.start(); - t.interrupt(); - lock.writeLock().unlock(); - t.join(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().tryLock(SMALL_DELAY_MS, MILLISECONDS); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + lock.writeLock().unlock(); + t.join(); } /** * read-lockInterruptibly is interruptible */ - public void testReadLockInterruptibly_Interrupted() { + public void testReadLockInterruptibly_Interrupted() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.readLock().lockInterruptibly(); - } catch(InterruptedException success){} - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().unlock(); - t.join(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.readLock().lockInterruptibly(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().unlock(); + t.join(); } /** * timed read-tryLock is interruptible */ - public void testReadTryLock_Interrupted() { + public void testReadTryLock_Interrupted() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(InterruptedException success){} - } - }); - try { - t.start(); - t.interrupt(); - t.join(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * write-tryLock fails if locked */ - public void testWriteTryLockWhenLocked() { + public void testWriteTryLockWhenLocked() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertFalse(lock.writeLock().tryLock()); - } - }); - try { - t.start(); - t.join(); - lock.writeLock().unlock(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + threadAssertFalse(lock.writeLock().tryLock()); + }}); + + t.start(); + t.join(); + lock.writeLock().unlock(); } /** * read-tryLock fails if locked */ - public void testReadTryLockWhenLocked() { + public void testReadTryLockWhenLocked() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertFalse(lock.readLock().tryLock()); - } - }); - try { - t.start(); - t.join(); - lock.writeLock().unlock(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + threadAssertFalse(lock.readLock().tryLock()); + }}); + + t.start(); + t.join(); + lock.writeLock().unlock(); } /** * Multiple threads can hold a read lock when not write-locked */ - public void testMultipleReadLocks() { + public void testMultipleReadLocks() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.readLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertTrue(lock.readLock().tryLock()); - lock.readLock().unlock(); - } - }); - try { - t.start(); - t.join(); - lock.readLock().unlock(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + threadAssertTrue(lock.readLock().tryLock()); + lock.readLock().unlock(); + }}); + + t.start(); + t.join(); + lock.readLock().unlock(); } /** * A writelock succeeds after reading threads unlock */ - public void testWriteAfterMultipleReadLocks() { + public void testWriteAfterMultipleReadLocks() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.readLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - - try { - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.readLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); - } catch(Exception e){ - unexpectedException(); - } + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.readLock().unlock(); + t1.join(MEDIUM_DELAY_MS); + t2.join(MEDIUM_DELAY_MS); + assertTrue(!t1.isAlive()); + assertTrue(!t2.isAlive()); } /** * Readlocks succeed after a writing thread unlocks */ - public void testReadAfterWriteLock() { + public void testReadAfterWriteLock() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - - try { - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); - - } catch(Exception e){ - unexpectedException(); - } + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().unlock(); + t1.join(MEDIUM_DELAY_MS); + t2.join(MEDIUM_DELAY_MS); + assertTrue(!t1.isAlive()); + assertTrue(!t2.isAlive()); } /** * Read trylock succeeds if write locked by current thread */ public void testReadHoldingWriteLock() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); assertTrue(lock.readLock().tryLock()); lock.readLock().unlock(); lock.writeLock().unlock(); @@ -394,78 +379,64 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { * Read lock succeeds if write locked by current thread even if * other threads are waiting for readlock */ - public void testReadHoldingWriteLock2() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - - try { - t1.start(); - t2.start(); - lock.readLock().lock(); - lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.readLock().lock(); - lock.readLock().unlock(); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); - - } catch(Exception e){ - unexpectedException(); - } + public void testReadHoldingWriteLock2() throws InterruptedException { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + + t1.start(); + t2.start(); + lock.readLock().lock(); + lock.readLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + lock.readLock().lock(); + lock.readLock().unlock(); + lock.writeLock().unlock(); + t1.join(MEDIUM_DELAY_MS); + t2.join(MEDIUM_DELAY_MS); + assertTrue(!t1.isAlive()); + assertTrue(!t2.isAlive()); } /** * Read lock succeeds if write locked by current thread even if * other threads are waiting for writelock */ - public void testReadHoldingWriteLock3() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - - try { - t1.start(); - t2.start(); - lock.readLock().lock(); - lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.readLock().lock(); - lock.readLock().unlock(); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + public void testReadHoldingWriteLock3() throws InterruptedException { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); - } catch(Exception e){ - unexpectedException(); - } + t1.start(); + t2.start(); + lock.readLock().lock(); + lock.readLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + lock.readLock().lock(); + lock.readLock().unlock(); + lock.writeLock().unlock(); + t1.join(MEDIUM_DELAY_MS); + t2.join(MEDIUM_DELAY_MS); + assertTrue(!t1.isAlive()); + assertTrue(!t2.isAlive()); } @@ -473,39 +444,32 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { * Write lock succeeds if write locked by current thread even if * other threads are waiting for writelock */ - public void testWriteHoldingWriteLock4() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - - try { - t1.start(); - t2.start(); - lock.writeLock().lock(); - lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - lock.writeLock().unlock(); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + public void testWriteHoldingWriteLock4() throws InterruptedException { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); - } catch(Exception e){ - unexpectedException(); - } + t1.start(); + t2.start(); + lock.writeLock().lock(); + lock.writeLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().lock(); + lock.writeLock().unlock(); + lock.writeLock().unlock(); + t1.join(MEDIUM_DELAY_MS); + t2.join(MEDIUM_DELAY_MS); + assertTrue(!t1.isAlive()); + assertTrue(!t2.isAlive()); } @@ -513,8 +477,8 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { * Fair Read trylock succeeds if write locked by current thread */ public void testReadHoldingWriteLockFair() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.writeLock().lock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.writeLock().lock(); assertTrue(lock.readLock().tryLock()); lock.readLock().unlock(); lock.writeLock().unlock(); @@ -524,39 +488,32 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { * Fair Read lock succeeds if write locked by current thread even if * other threads are waiting for readlock */ - public void testReadHoldingWriteLockFair2() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - - try { - t1.start(); - t2.start(); - lock.readLock().lock(); - lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.readLock().lock(); - lock.readLock().unlock(); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); - - } catch(Exception e){ - unexpectedException(); - } + public void testReadHoldingWriteLockFair2() throws InterruptedException { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.writeLock().lock(); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + + t1.start(); + t2.start(); + lock.readLock().lock(); + lock.readLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + lock.readLock().lock(); + lock.readLock().unlock(); + lock.writeLock().unlock(); + t1.join(MEDIUM_DELAY_MS); + t2.join(MEDIUM_DELAY_MS); + assertTrue(!t1.isAlive()); + assertTrue(!t2.isAlive()); } @@ -564,39 +521,32 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { * Fair Read lock succeeds if write locked by current thread even if * other threads are waiting for writelock */ - public void testReadHoldingWriteLockFair3() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - - try { - t1.start(); - t2.start(); - lock.readLock().lock(); - lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.readLock().lock(); - lock.readLock().unlock(); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + public void testReadHoldingWriteLockFair3() throws InterruptedException { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.writeLock().lock(); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); - } catch(Exception e){ - unexpectedException(); - } + t1.start(); + t2.start(); + lock.readLock().lock(); + lock.readLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + lock.readLock().lock(); + lock.readLock().unlock(); + lock.writeLock().unlock(); + t1.join(MEDIUM_DELAY_MS); + t2.join(MEDIUM_DELAY_MS); + assertTrue(!t1.isAlive()); + assertTrue(!t2.isAlive()); } @@ -604,64 +554,53 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { * Fair Write lock succeeds if write locked by current thread even if * other threads are waiting for writelock */ - public void testWriteHoldingWriteLockFair4() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - - try { - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.isWriteLockedByCurrentThread()); - assertTrue(lock.getWriteHoldCount() == 1); - lock.writeLock().lock(); - assertTrue(lock.getWriteHoldCount() == 2); - lock.writeLock().unlock(); - lock.writeLock().lock(); - lock.writeLock().unlock(); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + public void testWriteHoldingWriteLockFair4() throws InterruptedException { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.writeLock().lock(); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); - } catch(Exception e){ - unexpectedException(); - } + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.isWriteLockedByCurrentThread()); + assertTrue(lock.getWriteHoldCount() == 1); + lock.writeLock().lock(); + assertTrue(lock.getWriteHoldCount() == 2); + lock.writeLock().unlock(); + lock.writeLock().lock(); + lock.writeLock().unlock(); + lock.writeLock().unlock(); + t1.join(MEDIUM_DELAY_MS); + t2.join(MEDIUM_DELAY_MS); + assertTrue(!t1.isAlive()); + assertTrue(!t2.isAlive()); } /** * Read tryLock succeeds if readlocked but not writelocked */ - public void testTryLockWhenReadLocked() { + public void testTryLockWhenReadLocked() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.readLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertTrue(lock.readLock().tryLock()); - lock.readLock().unlock(); - } - }); - try { - t.start(); - t.join(); - lock.readLock().unlock(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + threadAssertTrue(lock.readLock().tryLock()); + lock.readLock().unlock(); + }}); + + t.start(); + t.join(); + lock.readLock().unlock(); } @@ -669,43 +608,35 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { /** * write tryLock fails when readlocked */ - public void testWriteTryLockWhenReadLocked() { + public void testWriteTryLockWhenReadLocked() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.readLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertFalse(lock.writeLock().tryLock()); - } - }); - try { - t.start(); - t.join(); - lock.readLock().unlock(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + threadAssertFalse(lock.writeLock().tryLock()); + }}); + + t.start(); + t.join(); + lock.readLock().unlock(); } /** * Fair Read tryLock succeeds if readlocked but not writelocked */ - public void testTryLockWhenReadLockedFair() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.readLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertTrue(lock.readLock().tryLock()); - lock.readLock().unlock(); - } - }); - try { - t.start(); - t.join(); - lock.readLock().unlock(); - } catch(Exception e){ - unexpectedException(); - } + public void testTryLockWhenReadLockedFair() throws InterruptedException { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.readLock().lock(); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + threadAssertTrue(lock.readLock().tryLock()); + lock.readLock().unlock(); + }}); + + t.start(); + t.join(); + lock.readLock().unlock(); } @@ -713,21 +644,17 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { /** * Fair write tryLock fails when readlocked */ - public void testWriteTryLockWhenReadLockedFair() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.readLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertFalse(lock.writeLock().tryLock()); - } - }); - try { - t.start(); - t.join(); - lock.readLock().unlock(); - } catch(Exception e){ - unexpectedException(); - } + public void testWriteTryLockWhenReadLockedFair() throws InterruptedException { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.readLock().lock(); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() { + threadAssertFalse(lock.writeLock().tryLock()); + }}); + + t.start(); + t.join(); + lock.readLock().unlock(); } @@ -735,130 +662,85 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { /** * write timed tryLock times out if locked */ - public void testWriteTryLock_Timeout() { + public void testWriteTryLock_Timeout() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertFalse(lock.writeLock().tryLock(1, TimeUnit.MILLISECONDS)); - } catch (Exception ex) { - threadUnexpectedException(); - } - } - }); - try { - t.start(); - t.join(); - lock.writeLock().unlock(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + threadAssertFalse(lock.writeLock().tryLock(1, MILLISECONDS)); + }}); + + t.start(); + t.join(); + assertTrue(lock.writeLock().isHeldByCurrentThread()); + lock.writeLock().unlock(); } /** * read timed tryLock times out if write-locked */ - public void testReadTryLock_Timeout() { + public void testReadTryLock_Timeout() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertFalse(lock.readLock().tryLock(1, TimeUnit.MILLISECONDS)); - } catch (Exception ex) { - threadUnexpectedException(); - } - } - }); - try { - t.start(); - t.join(); - lock.writeLock().unlock(); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + threadAssertFalse(lock.readLock().tryLock(1, MILLISECONDS)); + }}); + + t.start(); + t.join(); + assertTrue(lock.writeLock().isHeldByCurrentThread()); + lock.writeLock().unlock(); } /** * write lockInterruptibly succeeds if lock free else is interruptible */ - public void testWriteLockInterruptibly() { + public void testWriteLockInterruptibly() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - try { - lock.writeLock().lockInterruptibly(); - } catch(Exception e) { - unexpectedException(); - } - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lockInterruptibly(); - threadShouldThrow(); - } - catch(InterruptedException success) { - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - t.join(); - lock.writeLock().unlock(); - } catch(Exception e){ - unexpectedException(); - } + lock.writeLock().lockInterruptibly(); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lockInterruptibly(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + t.join(); + lock.writeLock().unlock(); } /** * read lockInterruptibly succeeds if lock free else is interruptible */ - public void testReadLockInterruptibly() { + public void testReadLockInterruptibly() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - try { - lock.writeLock().lockInterruptibly(); - } catch(Exception e) { - unexpectedException(); - } - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.readLock().lockInterruptibly(); - threadShouldThrow(); - } - catch(InterruptedException success) { - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - lock.writeLock().unlock(); - } catch(Exception e){ - unexpectedException(); - } + lock.writeLock().lockInterruptibly(); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.readLock().lockInterruptibly(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + lock.writeLock().unlock(); } /** * Calling await without holding lock throws IllegalMonitorStateException */ - public void testAwait_IllegalMonitor() { + public void testAwait_IllegalMonitor() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); try { c.await(); shouldThrow(); - } - catch (IllegalMonitorStateException success) { - } - catch (Exception ex) { - shouldThrow(); - } + } catch (IllegalMonitorStateException success) {} } /** @@ -870,94 +752,66 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { try { c.signal(); shouldThrow(); - } - catch (IllegalMonitorStateException success) { - } - catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } /** * awaitNanos without a signal times out */ - public void testAwaitNanos_Timeout() { + public void testAwaitNanos_Timeout() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - try { - lock.writeLock().lock(); - long t = c.awaitNanos(100); - assertTrue(t <= 0); - lock.writeLock().unlock(); - } - catch (Exception ex) { - unexpectedException(); - } + + lock.writeLock().lock(); + long t = c.awaitNanos(100); + assertTrue(t <= 0); + lock.writeLock().unlock(); } /** * timed await without a signal times out */ - public void testAwait_Timeout() { + public void testAwait_Timeout() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - try { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - catch (Exception ex) { - unexpectedException(); - } + lock.writeLock().lock(); + assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS)); + lock.writeLock().unlock(); } /** * awaitUntil without a signal times out */ - public void testAwaitUntil_Timeout() { + public void testAwaitUntil_Timeout() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - try { - lock.writeLock().lock(); - java.util.Date d = new java.util.Date(); - lock.writeLock().unlock(); - } - catch (Exception ex) { - unexpectedException(); - } + lock.writeLock().lock(); + java.util.Date d = new java.util.Date(); + assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10))); + lock.writeLock().unlock(); } /** * await returns when signalled */ - public void testAwait() { + public void testAwait() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lock(); - c.await(); - lock.writeLock().unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lock(); + c.await(); + lock.writeLock().unlock(); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - c.signal(); - lock.writeLock().unlock(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().lock(); + c.signal(); + lock.writeLock().unlock(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** A helper class for uninterruptible wait tests */ @@ -990,230 +844,167 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { /** * awaitUninterruptibly doesn't abort on interrupt */ - public void testAwaitUninterruptibly() { + public void testAwaitUninterruptibly() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); UninterruptableThread thread = new UninterruptableThread(lock.writeLock(), c); - try { - thread.start(); + thread.start(); - while (!thread.lockStarted) { - Thread.sleep(100); - } - - lock.writeLock().lock(); - try { - thread.interrupt(); - thread.canAwake = true; - c.signal(); - } finally { - lock.writeLock().unlock(); - } + while (!thread.lockStarted) { + Thread.sleep(100); + } - thread.join(); - assertTrue(thread.interrupted); - assertFalse(thread.isAlive()); - } catch (Exception ex) { - unexpectedException(); + lock.writeLock().lock(); + try { + thread.interrupt(); + thread.canAwake = true; + c.signal(); + } finally { + lock.writeLock().unlock(); } + + thread.join(); + assertTrue(thread.interrupted); + assertFalse(thread.isAlive()); } /** * await is interruptible */ - public void testAwait_Interrupt() { + public void testAwait_Interrupt() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lock(); - c.await(); - lock.writeLock().unlock(); - threadShouldThrow(); - } - catch(InterruptedException success) { - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lock(); + c.await(); + lock.writeLock().unlock(); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * awaitNanos is interruptible */ - public void testAwaitNanos_Interrupt() { + public void testAwaitNanos_Interrupt() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lock(); - c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000); - lock.writeLock().unlock(); - threadShouldThrow(); - } - catch(InterruptedException success) { - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lock(); + c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); + lock.writeLock().unlock(); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * awaitUntil is interruptible */ - public void testAwaitUntil_Interrupt() { + public void testAwaitUntil_Interrupt() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lock(); - java.util.Date d = new java.util.Date(); - c.awaitUntil(new java.util.Date(d.getTime() + 10000)); - lock.writeLock().unlock(); - threadShouldThrow(); - } - catch(InterruptedException success) { - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lock(); + java.util.Date d = new java.util.Date(); + c.awaitUntil(new java.util.Date(d.getTime() + 10000)); + lock.writeLock().unlock(); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * signalAll wakes up all threads */ - public void testSignalAll() { + public void testSignalAll() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lock(); - c.await(); - lock.writeLock().unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lock(); - c.await(); - lock.writeLock().unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lock(); + c.await(); + lock.writeLock().unlock(); + }}); - try { - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - c.signalAll(); - lock.writeLock().unlock(); - t1.join(SHORT_DELAY_MS); - t2.join(SHORT_DELAY_MS); - assertFalse(t1.isAlive()); - assertFalse(t2.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lock(); + c.await(); + lock.writeLock().unlock(); + }}); + + t1.start(); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().lock(); + c.signalAll(); + lock.writeLock().unlock(); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); } /** * A serialized lock deserializes as unlocked */ - public void testSerialization() { + public void testSerialization() throws Exception { ReentrantReadWriteLock l = new ReentrantReadWriteLock(); l.readLock().lock(); l.readLock().unlock(); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - ReentrantReadWriteLock r = (ReentrantReadWriteLock) in.readObject(); - r.readLock().lock(); - r.readLock().unlock(); - } catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + ReentrantReadWriteLock r = (ReentrantReadWriteLock) in.readObject(); + r.readLock().lock(); + r.readLock().unlock(); } /** * hasQueuedThreads reports whether there are waiting threads */ - public void testhasQueuedThreads() { + public void testhasQueuedThreads() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertFalse(lock.hasQueuedThreads()); - lock.writeLock().lock(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(lock.hasQueuedThreads()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } + assertFalse(lock.hasQueuedThreads()); + lock.writeLock().lock(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.hasQueuedThreads()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.hasQueuedThreads()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.hasQueuedThreads()); + lock.writeLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(lock.hasQueuedThreads()); + t1.join(); + t2.join(); } /** @@ -1224,104 +1015,91 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { try { sync.hasQueuedThread(null); shouldThrow(); - } catch (NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * hasQueuedThread reports whether a thread is queued. */ - public void testHasQueuedThread() { + public void testHasQueuedThread() throws InterruptedException { final ReentrantReadWriteLock sync = new ReentrantReadWriteLock(); Thread t1 = new Thread(new InterruptedLockRunnable(sync)); Thread t2 = new Thread(new InterruptibleLockRunnable(sync)); - try { - assertFalse(sync.hasQueuedThread(t1)); - assertFalse(sync.hasQueuedThread(t2)); - sync.writeLock().lock(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasQueuedThread(t1)); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasQueuedThread(t1)); - assertTrue(sync.hasQueuedThread(t2)); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.hasQueuedThread(t1)); - assertTrue(sync.hasQueuedThread(t2)); - sync.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.hasQueuedThread(t1)); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.hasQueuedThread(t2)); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } + assertFalse(sync.hasQueuedThread(t1)); + assertFalse(sync.hasQueuedThread(t2)); + sync.writeLock().lock(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThread(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(sync.hasQueuedThread(t1)); + assertTrue(sync.hasQueuedThread(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.hasQueuedThread(t1)); + assertTrue(sync.hasQueuedThread(t2)); + sync.writeLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.hasQueuedThread(t1)); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(sync.hasQueuedThread(t2)); + t1.join(); + t2.join(); } /** * getQueueLength reports number of waiting threads */ - public void testGetQueueLength() { + public void testGetQueueLength() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertEquals(0, lock.getQueueLength()); - lock.writeLock().lock(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, lock.getQueueLength()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(2, lock.getQueueLength()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, lock.getQueueLength()); - lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(0, lock.getQueueLength()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } + assertEquals(0, lock.getQueueLength()); + lock.writeLock().lock(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, lock.getQueueLength()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(2, lock.getQueueLength()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, lock.getQueueLength()); + lock.writeLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(0, lock.getQueueLength()); + t1.join(); + t2.join(); } /** * getQueuedThreads includes waiting threads */ - public void testGetQueuedThreads() { + public void testGetQueuedThreads() throws InterruptedException { final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertTrue(lock.getQueuedThreads().isEmpty()); - lock.writeLock().lock(); - assertTrue(lock.getQueuedThreads().isEmpty()); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.getQueuedThreads().contains(t1)); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.getQueuedThreads().contains(t1)); - assertTrue(lock.getQueuedThreads().contains(t2)); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(lock.getQueuedThreads().contains(t1)); - assertTrue(lock.getQueuedThreads().contains(t2)); - lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.getQueuedThreads().isEmpty()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } + assertTrue(lock.getQueuedThreads().isEmpty()); + lock.writeLock().lock(); + assertTrue(lock.getQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.getQueuedThreads().contains(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.getQueuedThreads().contains(t1)); + assertTrue(lock.getQueuedThreads().contains(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(lock.getQueuedThreads().contains(t1)); + assertTrue(lock.getQueuedThreads().contains(t2)); + lock.writeLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.getQueuedThreads().isEmpty()); + t1.join(); + t2.join(); } /** @@ -1332,10 +1110,7 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { try { lock.hasWaiters(null); shouldThrow(); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (NullPointerException success) {} } /** @@ -1346,10 +1121,7 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { try { lock.getWaitQueueLength(null); shouldThrow(); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (NullPointerException success) {} } @@ -1361,10 +1133,7 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { try { lock.getWaitingThreads(null); shouldThrow(); - } catch (NullPointerException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (NullPointerException success) {} } /** @@ -1372,15 +1141,12 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { */ public void testHasWaitersIAE() { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - final Condition c = (lock.writeLock().newCondition()); + final Condition c = lock.writeLock().newCondition(); final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(); try { lock2.hasWaiters(c); shouldThrow(); - } catch (IllegalArgumentException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalArgumentException success) {} } /** @@ -1388,14 +1154,11 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { */ public void testHasWaitersIMSE() { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - final Condition c = (lock.writeLock().newCondition()); + final Condition c = lock.writeLock().newCondition(); try { lock.hasWaiters(c); shouldThrow(); - } catch (IllegalMonitorStateException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } @@ -1404,15 +1167,12 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { */ public void testGetWaitQueueLengthIAE() { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - final Condition c = (lock.writeLock().newCondition()); + final Condition c = lock.writeLock().newCondition(); final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(); try { lock2.getWaitQueueLength(c); shouldThrow(); - } catch (IllegalArgumentException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalArgumentException success) {} } /** @@ -1420,14 +1180,11 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { */ public void testGetWaitQueueLengthIMSE() { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - final Condition c = (lock.writeLock().newCondition()); + final Condition c = lock.writeLock().newCondition(); try { lock.getWaitQueueLength(c); shouldThrow(); - } catch (IllegalMonitorStateException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } @@ -1436,15 +1193,12 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { */ public void testGetWaitingThreadsIAE() { final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); - final Condition c = (lock.writeLock().newCondition()); + final Condition c = lock.writeLock().newCondition(); final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock(); try { lock2.getWaitingThreads(c); shouldThrow(); - } catch (IllegalArgumentException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalArgumentException success) {} } /** @@ -1452,163 +1206,121 @@ public class ReentrantReadWriteLockTest extends JSR166TestCase { */ public void testGetWaitingThreadsIMSE() { final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); - final Condition c = (lock.writeLock().newCondition()); + final Condition c = lock.writeLock().newCondition(); try { lock.getWaitingThreads(c); shouldThrow(); - } catch (IllegalMonitorStateException success) { - } catch (Exception ex) { - unexpectedException(); - } + } catch (IllegalMonitorStateException success) {} } /** * hasWaiters returns true when a thread is waiting, else false */ - public void testHasWaiters() { + public void testHasWaiters() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - final Condition c = (lock.writeLock().newCondition()); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lock(); - threadAssertFalse(lock.hasWaiters(c)); - threadAssertEquals(0, lock.getWaitQueueLength(c)); - c.await(); - lock.writeLock().unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + final Condition c = lock.writeLock().newCondition(); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lock(); + threadAssertFalse(lock.hasWaiters(c)); + threadAssertEquals(0, lock.getWaitQueueLength(c)); + c.await(); + lock.writeLock().unlock(); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - assertTrue(lock.hasWaiters(c)); - assertEquals(1, lock.getWaitQueueLength(c)); - c.signal(); - lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - assertFalse(lock.hasWaiters(c)); - assertEquals(0, lock.getWaitQueueLength(c)); - lock.writeLock().unlock(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().lock(); + assertTrue(lock.hasWaiters(c)); + assertEquals(1, lock.getWaitQueueLength(c)); + c.signal(); + lock.writeLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().lock(); + assertFalse(lock.hasWaiters(c)); + assertEquals(0, lock.getWaitQueueLength(c)); + lock.writeLock().unlock(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * getWaitQueueLength returns number of waiting threads */ - public void testGetWaitQueueLength() { + public void testGetWaitQueueLength() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - final Condition c = (lock.writeLock().newCondition()); - Thread t = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lock(); - threadAssertFalse(lock.hasWaiters(c)); - threadAssertEquals(0, lock.getWaitQueueLength(c)); - c.await(); - lock.writeLock().unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + final Condition c = lock.writeLock().newCondition(); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lock(); + threadAssertFalse(lock.hasWaiters(c)); + threadAssertEquals(0, lock.getWaitQueueLength(c)); + c.await(); + lock.writeLock().unlock(); + }}); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - assertTrue(lock.hasWaiters(c)); - assertEquals(1, lock.getWaitQueueLength(c)); - c.signal(); - lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - assertFalse(lock.hasWaiters(c)); - assertEquals(0, lock.getWaitQueueLength(c)); - lock.writeLock().unlock(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + t.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().lock(); + assertTrue(lock.hasWaiters(c)); + assertEquals(1, lock.getWaitQueueLength(c)); + c.signal(); + lock.writeLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().lock(); + assertFalse(lock.hasWaiters(c)); + assertEquals(0, lock.getWaitQueueLength(c)); + lock.writeLock().unlock(); + t.join(SHORT_DELAY_MS); + assertFalse(t.isAlive()); } /** * getWaitingThreads returns only and all waiting threads */ - public void testGetWaitingThreads() { + public void testGetWaitingThreads() throws InterruptedException { final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lock(); - threadAssertTrue(lock.getWaitingThreads(c).isEmpty()); - c.await(); - lock.writeLock().unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - lock.writeLock().lock(); - threadAssertFalse(lock.getWaitingThreads(c).isEmpty()); - c.await(); - lock.writeLock().unlock(); - } - catch(InterruptedException e) { - threadUnexpectedException(); - } - } - }); + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lock(); + threadAssertTrue(lock.getWaitingThreads(c).isEmpty()); + c.await(); + lock.writeLock().unlock(); + }}); - try { - lock.writeLock().lock(); - assertTrue(lock.getWaitingThreads(c).isEmpty()); - lock.writeLock().unlock(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - assertTrue(lock.hasWaiters(c)); - assertTrue(lock.getWaitingThreads(c).contains(t1)); - assertTrue(lock.getWaitingThreads(c).contains(t2)); - c.signalAll(); - lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - assertFalse(lock.hasWaiters(c)); - assertTrue(lock.getWaitingThreads(c).isEmpty()); - lock.writeLock().unlock(); - t1.join(SHORT_DELAY_MS); - t2.join(SHORT_DELAY_MS); - assertFalse(t1.isAlive()); - assertFalse(t2.isAlive()); - } - catch (Exception ex) { - unexpectedException(); - } + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + lock.writeLock().lock(); + threadAssertFalse(lock.getWaitingThreads(c).isEmpty()); + c.await(); + lock.writeLock().unlock(); + }}); + + lock.writeLock().lock(); + assertTrue(lock.getWaitingThreads(c).isEmpty()); + lock.writeLock().unlock(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().lock(); + assertTrue(lock.hasWaiters(c)); + assertTrue(lock.getWaitingThreads(c).contains(t1)); + assertTrue(lock.getWaitingThreads(c).contains(t2)); + c.signalAll(); + lock.writeLock().unlock(); + Thread.sleep(SHORT_DELAY_MS); + lock.writeLock().lock(); + assertFalse(lock.hasWaiters(c)); + assertTrue(lock.getWaitingThreads(c).isEmpty()); + lock.writeLock().unlock(); + t1.join(SHORT_DELAY_MS); + t2.join(SHORT_DELAY_MS); + assertFalse(t1.isAlive()); + assertFalse(t2.isAlive()); } /** diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ScheduledExecutorSubclassTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ScheduledExecutorSubclassTest.java new file mode 100644 index 0000000..21f4ced --- /dev/null +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ScheduledExecutorSubclassTest.java @@ -0,0 +1,1060 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + */ + +package tests.api.java.util.concurrent; // android-added + +import junit.framework.*; +import java.util.*; +import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; +import java.util.concurrent.atomic.*; + +public class ScheduledExecutorSubclassTest extends JSR166TestCase { + public static Test suite() { + return new TestSuite(ScheduledExecutorSubclassTest.class); + } + + static class CustomTask<V> implements RunnableScheduledFuture<V> { + RunnableScheduledFuture<V> task; + volatile boolean ran; + CustomTask(RunnableScheduledFuture<V> t) { task = t; } + public boolean isPeriodic() { return task.isPeriodic(); } + public void run() { + ran = true; + task.run(); + } + public long getDelay(TimeUnit unit) { return task.getDelay(unit); } + public int compareTo(Delayed t) { + return task.compareTo(((CustomTask)t).task); + } + public boolean cancel(boolean mayInterruptIfRunning) { + return task.cancel(mayInterruptIfRunning); + } + public boolean isCancelled() { return task.isCancelled(); } + public boolean isDone() { return task.isDone(); } + public V get() throws InterruptedException, ExecutionException { + V v = task.get(); + assertTrue(ran); + return v; + } + public V get(long time, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { + V v = task.get(time, unit); + assertTrue(ran); + return v; + } + } + + + public class CustomExecutor extends ScheduledThreadPoolExecutor { + + protected <V> RunnableScheduledFuture<V> decorateTask(Runnable r, RunnableScheduledFuture<V> task) { + return new CustomTask<V>(task); + } + + protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> c, RunnableScheduledFuture<V> task) { + return new CustomTask<V>(task); + } + CustomExecutor(int corePoolSize) { super(corePoolSize);} + CustomExecutor(int corePoolSize, RejectedExecutionHandler handler) { + super(corePoolSize, handler); + } + + CustomExecutor(int corePoolSize, ThreadFactory threadFactory) { + super(corePoolSize, threadFactory); + } + CustomExecutor(int corePoolSize, ThreadFactory threadFactory, + RejectedExecutionHandler handler) { + super(corePoolSize, threadFactory, handler); + } + + } + + + /** + * execute successfully executes a runnable + */ + public void testExecute() throws InterruptedException { + TrackedShortRunnable runnable =new TrackedShortRunnable(); + CustomExecutor p1 = new CustomExecutor(1); + p1.execute(runnable); + assertFalse(runnable.done); + Thread.sleep(SHORT_DELAY_MS); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(runnable.done); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + joinPool(p1); + } + + + /** + * delayed schedule of callable successfully executes after delay + */ + public void testSchedule1() throws Exception { + TrackedCallable callable = new TrackedCallable(); + CustomExecutor p1 = new CustomExecutor(1); + Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS); + assertFalse(callable.done); + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(callable.done); + assertEquals(Boolean.TRUE, f.get()); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + joinPool(p1); + } + + /** + * delayed schedule of runnable successfully executes after delay + */ + public void testSchedule3() throws InterruptedException { + TrackedShortRunnable runnable = new TrackedShortRunnable(); + CustomExecutor p1 = new CustomExecutor(1); + p1.schedule(runnable, SMALL_DELAY_MS, MILLISECONDS); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(runnable.done); + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(runnable.done); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + joinPool(p1); + } + + /** + * scheduleAtFixedRate executes runnable after given initial delay + */ + public void testSchedule4() throws InterruptedException { + TrackedShortRunnable runnable = new TrackedShortRunnable(); + CustomExecutor p1 = new CustomExecutor(1); + ScheduledFuture h = p1.scheduleAtFixedRate(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, MILLISECONDS); + assertFalse(runnable.done); + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(runnable.done); + h.cancel(true); + joinPool(p1); + } + + static class RunnableCounter implements Runnable { + AtomicInteger count = new AtomicInteger(0); + public void run() { count.getAndIncrement(); } + } + + /** + * scheduleWithFixedDelay executes runnable after given initial delay + */ + public void testSchedule5() throws InterruptedException { + TrackedShortRunnable runnable = new TrackedShortRunnable(); + CustomExecutor p1 = new CustomExecutor(1); + ScheduledFuture h = p1.scheduleWithFixedDelay(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, MILLISECONDS); + assertFalse(runnable.done); + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(runnable.done); + h.cancel(true); + joinPool(p1); + } + + /** + * scheduleAtFixedRate executes series of tasks at given rate + */ + public void testFixedRateSequence() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + RunnableCounter counter = new RunnableCounter(); + ScheduledFuture h = + p1.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS); + Thread.sleep(SMALL_DELAY_MS); + h.cancel(true); + int c = counter.count.get(); + // By time scaling conventions, we must have at least + // an execution per SHORT delay, but no more than one SHORT more + assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS); + assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS); + joinPool(p1); + } + + /** + * scheduleWithFixedDelay executes series of tasks with given period + */ + public void testFixedDelaySequence() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + RunnableCounter counter = new RunnableCounter(); + ScheduledFuture h = + p1.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS); + Thread.sleep(SMALL_DELAY_MS); + h.cancel(true); + int c = counter.count.get(); + assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS); + assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS); + joinPool(p1); + } + + + /** + * execute (null) throws NPE + */ + public void testExecuteNull() throws InterruptedException { + CustomExecutor se = new CustomExecutor(1); + try { + se.execute(null); + shouldThrow(); + } catch (NullPointerException success) {} + joinPool(se); + } + + /** + * schedule (null) throws NPE + */ + public void testScheduleNull() throws InterruptedException { + CustomExecutor se = new CustomExecutor(1); + try { + TrackedCallable callable = null; + Future f = se.schedule(callable, SHORT_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) {} + joinPool(se); + } + + /** + * execute throws RejectedExecutionException if shutdown + */ + public void testSchedule1_RejectedExecutionException() { + CustomExecutor se = new CustomExecutor(1); + try { + se.shutdown(); + se.schedule(new NoOpRunnable(), + MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (RejectedExecutionException success) { + } catch (SecurityException ok) { + } + + joinPool(se); + } + + /** + * schedule throws RejectedExecutionException if shutdown + */ + public void testSchedule2_RejectedExecutionException() { + CustomExecutor se = new CustomExecutor(1); + try { + se.shutdown(); + se.schedule(new NoOpCallable(), + MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (RejectedExecutionException success) { + } catch (SecurityException ok) { + } + joinPool(se); + } + + /** + * schedule callable throws RejectedExecutionException if shutdown + */ + public void testSchedule3_RejectedExecutionException() { + CustomExecutor se = new CustomExecutor(1); + try { + se.shutdown(); + se.schedule(new NoOpCallable(), + MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (RejectedExecutionException success) { + } catch (SecurityException ok) { + } + joinPool(se); + } + + /** + * scheduleAtFixedRate throws RejectedExecutionException if shutdown + */ + public void testScheduleAtFixedRate1_RejectedExecutionException() { + CustomExecutor se = new CustomExecutor(1); + try { + se.shutdown(); + se.scheduleAtFixedRate(new NoOpRunnable(), + MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (RejectedExecutionException success) { + } catch (SecurityException ok) { + } + joinPool(se); + } + + /** + * scheduleWithFixedDelay throws RejectedExecutionException if shutdown + */ + public void testScheduleWithFixedDelay1_RejectedExecutionException() { + CustomExecutor se = new CustomExecutor(1); + try { + se.shutdown(); + se.scheduleWithFixedDelay(new NoOpRunnable(), + MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (RejectedExecutionException success) { + } catch (SecurityException ok) { + } + joinPool(se); + } + + /** + * getActiveCount increases but doesn't overestimate, when a + * thread becomes active + */ + public void testGetActiveCount() throws InterruptedException { + CustomExecutor p2 = new CustomExecutor(2); + assertEquals(0, p2.getActiveCount()); + p2.execute(new SmallRunnable()); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, p2.getActiveCount()); + joinPool(p2); + } + + /** + * getCompletedTaskCount increases, but doesn't overestimate, + * when tasks complete + */ + public void testGetCompletedTaskCount() throws InterruptedException { + CustomExecutor p2 = new CustomExecutor(2); + assertEquals(0, p2.getCompletedTaskCount()); + p2.execute(new SmallRunnable()); + Thread.sleep(MEDIUM_DELAY_MS); + assertEquals(1, p2.getCompletedTaskCount()); + joinPool(p2); + } + + /** + * getCorePoolSize returns size given in constructor if not otherwise set + */ + public void testGetCorePoolSize() { + CustomExecutor p1 = new CustomExecutor(1); + assertEquals(1, p1.getCorePoolSize()); + joinPool(p1); + } + + /** + * getLargestPoolSize increases, but doesn't overestimate, when + * multiple threads active + */ + public void testGetLargestPoolSize() throws InterruptedException { + CustomExecutor p2 = new CustomExecutor(2); + assertEquals(0, p2.getLargestPoolSize()); + p2.execute(new SmallRunnable()); + p2.execute(new SmallRunnable()); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(2, p2.getLargestPoolSize()); + joinPool(p2); + } + + /** + * getPoolSize increases, but doesn't overestimate, when threads + * become active + */ + public void testGetPoolSize() { + CustomExecutor p1 = new CustomExecutor(1); + assertEquals(0, p1.getPoolSize()); + p1.execute(new SmallRunnable()); + assertEquals(1, p1.getPoolSize()); + joinPool(p1); + } + + /** + * getTaskCount increases, but doesn't overestimate, when tasks + * submitted + */ + public void testGetTaskCount() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + assertEquals(0, p1.getTaskCount()); + for (int i = 0; i < 5; i++) + p1.execute(new SmallRunnable()); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(5, p1.getTaskCount()); + joinPool(p1); + } + + /** + * getThreadFactory returns factory in constructor if not set + */ + public void testGetThreadFactory() { + ThreadFactory tf = new SimpleThreadFactory(); + CustomExecutor p = new CustomExecutor(1, tf); + assertSame(tf, p.getThreadFactory()); + joinPool(p); + } + + /** + * setThreadFactory sets the thread factory returned by getThreadFactory + */ + public void testSetThreadFactory() { + ThreadFactory tf = new SimpleThreadFactory(); + CustomExecutor p = new CustomExecutor(1); + p.setThreadFactory(tf); + assertSame(tf, p.getThreadFactory()); + joinPool(p); + } + + /** + * setThreadFactory(null) throws NPE + */ + public void testSetThreadFactoryNull() { + CustomExecutor p = new CustomExecutor(1); + try { + p.setThreadFactory(null); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(p); + } + } + + /** + * is isShutDown is false before shutdown, true after + */ + public void testIsShutdown() { + CustomExecutor p1 = new CustomExecutor(1); + try { + assertFalse(p1.isShutdown()); + } + finally { + try { p1.shutdown(); } catch (SecurityException ok) { return; } + } + assertTrue(p1.isShutdown()); + } + + + /** + * isTerminated is false before termination, true after + */ + public void testIsTerminated() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + try { + p1.execute(new SmallRunnable()); + } finally { + try { p1.shutdown(); } catch (SecurityException ok) { return; } + } + assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue(p1.isTerminated()); + } + + /** + * isTerminating is not true when running or when terminated + */ + public void testIsTerminating() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + assertFalse(p1.isTerminating()); + try { + p1.execute(new SmallRunnable()); + assertFalse(p1.isTerminating()); + } finally { + try { p1.shutdown(); } catch (SecurityException ok) { return; } + } + assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue(p1.isTerminated()); + assertFalse(p1.isTerminating()); + } + + /** + * getQueue returns the work queue, which contains queued tasks + */ + public void testGetQueue() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + ScheduledFuture[] tasks = new ScheduledFuture[5]; + for (int i = 0; i < 5; i++) { + tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, MILLISECONDS); + } + try { + Thread.sleep(SHORT_DELAY_MS); + BlockingQueue<Runnable> q = p1.getQueue(); + assertTrue(q.contains(tasks[4])); + assertFalse(q.contains(tasks[0])); + } finally { + joinPool(p1); + } + } + + /** + * remove(task) removes queued task, and fails to remove active task + */ + public void testRemove() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + ScheduledFuture[] tasks = new ScheduledFuture[5]; + for (int i = 0; i < 5; i++) { + tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, MILLISECONDS); + } + try { + Thread.sleep(SHORT_DELAY_MS); + BlockingQueue<Runnable> q = p1.getQueue(); + assertFalse(p1.remove((Runnable)tasks[0])); + assertTrue(q.contains((Runnable)tasks[4])); + assertTrue(q.contains((Runnable)tasks[3])); + assertTrue(p1.remove((Runnable)tasks[4])); + assertFalse(p1.remove((Runnable)tasks[4])); + assertFalse(q.contains((Runnable)tasks[4])); + assertTrue(q.contains((Runnable)tasks[3])); + assertTrue(p1.remove((Runnable)tasks[3])); + assertFalse(q.contains((Runnable)tasks[3])); + } finally { + joinPool(p1); + } + } + + /** + * purge removes cancelled tasks from the queue + */ + public void testPurge() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + ScheduledFuture[] tasks = new ScheduledFuture[5]; + for (int i = 0; i < 5; i++) { + tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS); + } + try { + int max = 5; + if (tasks[4].cancel(true)) --max; + if (tasks[3].cancel(true)) --max; + // There must eventually be an interference-free point at + // which purge will not fail. (At worst, when queue is empty.) + int k; + for (k = 0; k < SMALL_DELAY_MS; ++k) { + p1.purge(); + long count = p1.getTaskCount(); + if (count >= 0 && count <= max) + break; + Thread.sleep(1); + } + assertTrue(k < SMALL_DELAY_MS); + } finally { + joinPool(p1); + } + } + + /** + * shutDownNow returns a list containing tasks that were not run + */ + public void testShutDownNow() { + CustomExecutor p1 = new CustomExecutor(1); + for (int i = 0; i < 5; i++) + p1.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS); + List l; + try { + l = p1.shutdownNow(); + } catch (SecurityException ok) { + return; + } + assertTrue(p1.isShutdown()); + assertTrue(l.size() > 0 && l.size() <= 5); + joinPool(p1); + } + + /** + * In default setting, shutdown cancels periodic but not delayed + * tasks at shutdown + */ + public void testShutDown1() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + assertTrue(p1.getExecuteExistingDelayedTasksAfterShutdownPolicy()); + assertFalse(p1.getContinueExistingPeriodicTasksAfterShutdownPolicy()); + + ScheduledFuture[] tasks = new ScheduledFuture[5]; + for (int i = 0; i < 5; i++) + tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, MILLISECONDS); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + BlockingQueue q = p1.getQueue(); + for (Iterator it = q.iterator(); it.hasNext();) { + ScheduledFuture t = (ScheduledFuture)it.next(); + assertFalse(t.isCancelled()); + } + assertTrue(p1.isShutdown()); + Thread.sleep(SMALL_DELAY_MS); + for (int i = 0; i < 5; ++i) { + assertTrue(tasks[i].isDone()); + assertFalse(tasks[i].isCancelled()); + } + } + + + /** + * If setExecuteExistingDelayedTasksAfterShutdownPolicy is false, + * delayed tasks are cancelled at shutdown + */ + public void testShutDown2() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + p1.setExecuteExistingDelayedTasksAfterShutdownPolicy(false); + ScheduledFuture[] tasks = new ScheduledFuture[5]; + for (int i = 0; i < 5; i++) + tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, MILLISECONDS); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + assertTrue(p1.isShutdown()); + BlockingQueue q = p1.getQueue(); + assertTrue(q.isEmpty()); + Thread.sleep(SMALL_DELAY_MS); + assertTrue(p1.isTerminated()); + } + + + /** + * If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false, + * periodic tasks are not cancelled at shutdown + */ + public void testShutDown3() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + p1.setContinueExistingPeriodicTasksAfterShutdownPolicy(false); + ScheduledFuture task = + p1.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, MILLISECONDS); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + assertTrue(p1.isShutdown()); + BlockingQueue q = p1.getQueue(); + assertTrue(q.isEmpty()); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(p1.isTerminated()); + } + + /** + * if setContinueExistingPeriodicTasksAfterShutdownPolicy is true, + * periodic tasks are cancelled at shutdown + */ + public void testShutDown4() throws InterruptedException { + CustomExecutor p1 = new CustomExecutor(1); + try { + p1.setContinueExistingPeriodicTasksAfterShutdownPolicy(true); + ScheduledFuture task = + p1.scheduleAtFixedRate(new NoOpRunnable(), 1, 1, MILLISECONDS); + assertFalse(task.isCancelled()); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + assertFalse(task.isCancelled()); + assertFalse(p1.isTerminated()); + assertTrue(p1.isShutdown()); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(task.isCancelled()); + assertTrue(task.cancel(true)); + assertTrue(task.isDone()); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(p1.isTerminated()); + } + finally { + joinPool(p1); + } + } + + /** + * completed submit of callable returns result + */ + public void testSubmitCallable() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + Future<String> future = e.submit(new StringTask()); + String result = future.get(); + assertSame(TEST_STRING, result); + } finally { + joinPool(e); + } + } + + /** + * completed submit of runnable returns successfully + */ + public void testSubmitRunnable() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + Future<?> future = e.submit(new NoOpRunnable()); + future.get(); + assertTrue(future.isDone()); + } finally { + joinPool(e); + } + } + + /** + * completed submit of (runnable, result) returns result + */ + public void testSubmitRunnable2() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING); + String result = future.get(); + assertSame(TEST_STRING, result); + } finally { + joinPool(e); + } + } + + /** + * invokeAny(null) throws NPE + */ + public void testInvokeAny1() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + e.invokeAny(null); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * invokeAny(empty collection) throws IAE + */ + public void testInvokeAny2() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + e.invokeAny(new ArrayList<Callable<String>>()); + shouldThrow(); + } catch (IllegalArgumentException success) { + } finally { + joinPool(e); + } + } + + /** + * invokeAny(c) throws NPE if c has null elements + */ + public void testInvokeAny3() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + ExecutorService e = new CustomExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(latchAwaitingStringTask(latch)); + l.add(null); + try { + e.invokeAny(l); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + latch.countDown(); + joinPool(e); + } + } + + /** + * invokeAny(c) throws ExecutionException if no task completes + */ + public void testInvokeAny4() throws Exception { + ExecutorService e = new CustomExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); + try { + e.invokeAny(l); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } finally { + joinPool(e); + } + } + + /** + * invokeAny(c) returns result of some task + */ + public void testInvokeAny5() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(new StringTask()); + String result = e.invokeAny(l); + assertSame(TEST_STRING, result); + } finally { + joinPool(e); + } + } + + /** + * invokeAll(null) throws NPE + */ + public void testInvokeAll1() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + e.invokeAll(null); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * invokeAll(empty collection) returns empty collection + */ + public void testInvokeAll2() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>()); + assertTrue(r.isEmpty()); + } finally { + joinPool(e); + } + } + + /** + * invokeAll(c) throws NPE if c has null elements + */ + public void testInvokeAll3() throws Exception { + ExecutorService e = new CustomExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(null); + try { + e.invokeAll(l); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * get of invokeAll(c) throws exception on failed task + */ + public void testInvokeAll4() throws Exception { + ExecutorService e = new CustomExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); + List<Future<String>> futures = e.invokeAll(l); + assertEquals(1, futures.size()); + try { + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } finally { + joinPool(e); + } + } + + /** + * invokeAll(c) returns results of all completed tasks + */ + public void testInvokeAll5() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(new StringTask()); + List<Future<String>> futures = e.invokeAll(l); + assertEquals(2, futures.size()); + for (Future<String> future : futures) + assertSame(TEST_STRING, future.get()); + } finally { + joinPool(e); + } + } + + /** + * timed invokeAny(null) throws NPE + */ + public void testTimedInvokeAny1() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * timed invokeAny(,,null) throws NPE + */ + public void testTimedInvokeAnyNullTimeUnit() throws Exception { + ExecutorService e = new CustomExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + try { + e.invokeAny(l, MEDIUM_DELAY_MS, null); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * timed invokeAny(empty collection) throws IAE + */ + public void testTimedInvokeAny2() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (IllegalArgumentException success) { + } finally { + joinPool(e); + } + } + + /** + * timed invokeAny(c) throws NPE if c has null elements + */ + public void testTimedInvokeAny3() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + ExecutorService e = new CustomExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(latchAwaitingStringTask(latch)); + l.add(null); + try { + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + latch.countDown(); + joinPool(e); + } + } + + /** + * timed invokeAny(c) throws ExecutionException if no task completes + */ + public void testTimedInvokeAny4() throws Exception { + ExecutorService e = new CustomExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); + try { + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } finally { + joinPool(e); + } + } + + /** + * timed invokeAny(c) returns result of some task + */ + public void testTimedInvokeAny5() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(new StringTask()); + String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertSame(TEST_STRING, result); + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(null) throws NPE + */ + public void testTimedInvokeAll1() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(,,null) throws NPE + */ + public void testTimedInvokeAllNullTimeUnit() throws Exception { + ExecutorService e = new CustomExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + try { + e.invokeAll(l, MEDIUM_DELAY_MS, null); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(empty collection) returns empty collection + */ + public void testTimedInvokeAll2() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); + assertTrue(r.isEmpty()); + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(c) throws NPE if c has null elements + */ + public void testTimedInvokeAll3() throws Exception { + ExecutorService e = new CustomExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(null); + try { + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * get of element of invokeAll(c) throws exception on failed task + */ + public void testTimedInvokeAll4() throws Exception { + ExecutorService e = new CustomExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); + List<Future<String>> futures = + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertEquals(1, futures.size()); + try { + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(c) returns results of all completed tasks + */ + public void testTimedInvokeAll5() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(new StringTask()); + List<Future<String>> futures = + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertEquals(2, futures.size()); + for (Future<String> future : futures) + assertSame(TEST_STRING, future.get()); + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(c) cancels tasks not completed by timeout + */ + public void testTimedInvokeAll6() throws Exception { + ExecutorService e = new CustomExecutor(2); + try { + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING)); + l.add(new StringTask()); + List<Future<String>> futures = + e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS); + assertEquals(3, futures.size()); + Iterator<Future<String>> it = futures.iterator(); + Future<String> f1 = it.next(); + Future<String> f2 = it.next(); + Future<String> f3 = it.next(); + assertTrue(f1.isDone()); + assertTrue(f2.isDone()); + assertTrue(f3.isDone()); + assertFalse(f1.isCancelled()); + assertTrue(f2.isCancelled()); + } finally { + joinPool(e); + } + } + +} diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ScheduledExecutorTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ScheduledExecutorTest.java index 14e98b4..ff1796e 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ScheduledExecutorTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ScheduledExecutorTest.java @@ -2,15 +2,16 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.util.concurrent.atomic.*; public class ScheduledExecutorTest extends JSR166TestCase { @@ -22,86 +23,62 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * execute successfully executes a runnable */ - public void testExecute() { - try { - TrackedShortRunnable runnable =new TrackedShortRunnable(); - ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); - p1.execute(runnable); - assertFalse(runnable.done); - Thread.sleep(SHORT_DELAY_MS); - try { p1.shutdown(); } catch(SecurityException ok) { return; } - try { - Thread.sleep(MEDIUM_DELAY_MS); - } catch(InterruptedException e){ - unexpectedException(); - } - assertTrue(runnable.done); - try { p1.shutdown(); } catch(SecurityException ok) { return; } - joinPool(p1); - } - catch(Exception e){ - unexpectedException(); - } - + public void testExecute() throws InterruptedException { + TrackedShortRunnable runnable =new TrackedShortRunnable(); + ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); + p1.execute(runnable); + assertFalse(runnable.done); + Thread.sleep(SHORT_DELAY_MS); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(runnable.done); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + joinPool(p1); } /** * delayed schedule of callable successfully executes after delay */ - public void testSchedule1() { - try { - TrackedCallable callable = new TrackedCallable(); - ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); - Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - assertFalse(callable.done); - Thread.sleep(MEDIUM_DELAY_MS); - assertTrue(callable.done); - assertEquals(Boolean.TRUE, f.get()); - try { p1.shutdown(); } catch(SecurityException ok) { return; } - joinPool(p1); - } catch(RejectedExecutionException e){} - catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + public void testSchedule1() throws Exception { + TrackedCallable callable = new TrackedCallable(); + ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); + Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS); + assertFalse(callable.done); + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(callable.done); + assertEquals(Boolean.TRUE, f.get()); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + joinPool(p1); } /** * delayed schedule of runnable successfully executes after delay */ - public void testSchedule3() { - try { - TrackedShortRunnable runnable = new TrackedShortRunnable(); - ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); - p1.schedule(runnable, SMALL_DELAY_MS, TimeUnit.MILLISECONDS); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(runnable.done); - Thread.sleep(MEDIUM_DELAY_MS); - assertTrue(runnable.done); - try { p1.shutdown(); } catch(SecurityException ok) { return; } - joinPool(p1); - } catch(Exception e){ - unexpectedException(); - } + public void testSchedule3() throws InterruptedException { + TrackedShortRunnable runnable = new TrackedShortRunnable(); + ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); + p1.schedule(runnable, SMALL_DELAY_MS, MILLISECONDS); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(runnable.done); + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(runnable.done); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + joinPool(p1); } - + /** * scheduleAtFixedRate executes runnable after given initial delay */ - public void testSchedule4() { - try { - TrackedShortRunnable runnable = new TrackedShortRunnable(); - ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); - ScheduledFuture h = p1.scheduleAtFixedRate(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - assertFalse(runnable.done); - Thread.sleep(MEDIUM_DELAY_MS); - assertTrue(runnable.done); - h.cancel(true); - joinPool(p1); - } catch(Exception e){ - unexpectedException(); - } + public void testSchedule4() throws InterruptedException { + TrackedShortRunnable runnable = new TrackedShortRunnable(); + ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); + ScheduledFuture h = p1.scheduleAtFixedRate(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, MILLISECONDS); + assertFalse(runnable.done); + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(runnable.done); + h.cancel(true); + joinPool(p1); } static class RunnableCounter implements Runnable { @@ -112,126 +89,107 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * scheduleWithFixedDelay executes runnable after given initial delay */ - public void testSchedule5() { - try { - TrackedShortRunnable runnable = new TrackedShortRunnable(); - ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); - ScheduledFuture h = p1.scheduleWithFixedDelay(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - assertFalse(runnable.done); - Thread.sleep(MEDIUM_DELAY_MS); - assertTrue(runnable.done); - h.cancel(true); - joinPool(p1); - } catch(Exception e){ - unexpectedException(); - } + public void testSchedule5() throws InterruptedException { + TrackedShortRunnable runnable = new TrackedShortRunnable(); + ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); + ScheduledFuture h = p1.scheduleWithFixedDelay(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, MILLISECONDS); + assertFalse(runnable.done); + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(runnable.done); + h.cancel(true); + joinPool(p1); } - + /** * scheduleAtFixedRate executes series of tasks at given rate */ - public void testFixedRateSequence() { - try { - ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); - RunnableCounter counter = new RunnableCounter(); - ScheduledFuture h = - p1.scheduleAtFixedRate(counter, 0, 1, TimeUnit.MILLISECONDS); - Thread.sleep(SMALL_DELAY_MS); - h.cancel(true); - int c = counter.count.get(); - // By time scaling conventions, we must have at least - // an execution per SHORT delay, but no more than one SHORT more - assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS); - assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS); - joinPool(p1); - } catch(Exception e){ - unexpectedException(); - } + public void testFixedRateSequence() throws InterruptedException { + ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); + RunnableCounter counter = new RunnableCounter(); + ScheduledFuture h = + p1.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS); + Thread.sleep(SMALL_DELAY_MS); + h.cancel(true); + int c = counter.count.get(); + // By time scaling conventions, we must have at least + // an execution per SHORT delay, but no more than one SHORT more + assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS); + assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS); + joinPool(p1); } /** * scheduleWithFixedDelay executes series of tasks with given period */ - public void testFixedDelaySequence() { - try { - ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); - RunnableCounter counter = new RunnableCounter(); - ScheduledFuture h = - p1.scheduleWithFixedDelay(counter, 0, 1, TimeUnit.MILLISECONDS); - Thread.sleep(SMALL_DELAY_MS); - h.cancel(true); - int c = counter.count.get(); - assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS); - assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS); - joinPool(p1); - } catch(Exception e){ - unexpectedException(); - } + public void testFixedDelaySequence() throws InterruptedException { + ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); + RunnableCounter counter = new RunnableCounter(); + ScheduledFuture h = + p1.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS); + Thread.sleep(SMALL_DELAY_MS); + h.cancel(true); + int c = counter.count.get(); + assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS); + assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS); + joinPool(p1); } /** * execute (null) throws NPE */ - public void testExecuteNull() { + public void testExecuteNull() throws InterruptedException { ScheduledThreadPoolExecutor se = null; try { se = new ScheduledThreadPoolExecutor(1); se.execute(null); shouldThrow(); - } catch(NullPointerException success){} - catch(Exception e){ - unexpectedException(); - } - + } catch (NullPointerException success) {} + joinPool(se); } /** * schedule (null) throws NPE */ - public void testScheduleNull() { + public void testScheduleNull() throws InterruptedException { ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1); try { TrackedCallable callable = null; - Future f = se.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); + Future f = se.schedule(callable, SHORT_DELAY_MS, MILLISECONDS); shouldThrow(); - } catch(NullPointerException success){} - catch(Exception e){ - unexpectedException(); - } + } catch (NullPointerException success) {} joinPool(se); } - + /** * execute throws RejectedExecutionException if shutdown */ - public void testSchedule1_RejectedExecutionException() { + public void testSchedule1_RejectedExecutionException() throws InterruptedException { ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1); try { se.shutdown(); se.schedule(new NoOpRunnable(), - MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + MEDIUM_DELAY_MS, MILLISECONDS); shouldThrow(); - } catch(RejectedExecutionException success){ + } catch (RejectedExecutionException success) { } catch (SecurityException ok) { } - - joinPool(se); + joinPool(se); } /** * schedule throws RejectedExecutionException if shutdown */ - public void testSchedule2_RejectedExecutionException() { + public void testSchedule2_RejectedExecutionException() throws InterruptedException { ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1); try { se.shutdown(); se.schedule(new NoOpCallable(), - MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + MEDIUM_DELAY_MS, MILLISECONDS); shouldThrow(); - } catch(RejectedExecutionException success){ + } catch (RejectedExecutionException success) { } catch (SecurityException ok) { } joinPool(se); @@ -240,14 +198,14 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * schedule callable throws RejectedExecutionException if shutdown */ - public void testSchedule3_RejectedExecutionException() { + public void testSchedule3_RejectedExecutionException() throws InterruptedException { ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1); try { se.shutdown(); se.schedule(new NoOpCallable(), - MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + MEDIUM_DELAY_MS, MILLISECONDS); shouldThrow(); - } catch(RejectedExecutionException success){ + } catch (RejectedExecutionException success) { } catch (SecurityException ok) { } joinPool(se); @@ -256,32 +214,32 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * scheduleAtFixedRate throws RejectedExecutionException if shutdown */ - public void testScheduleAtFixedRate1_RejectedExecutionException() { + public void testScheduleAtFixedRate1_RejectedExecutionException() throws InterruptedException { ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1); try { se.shutdown(); se.scheduleAtFixedRate(new NoOpRunnable(), - MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS); shouldThrow(); - } catch(RejectedExecutionException success){ + } catch (RejectedExecutionException success) { } catch (SecurityException ok) { - } + } joinPool(se); } - + /** * scheduleWithFixedDelay throws RejectedExecutionException if shutdown */ - public void testScheduleWithFixedDelay1_RejectedExecutionException() { + public void testScheduleWithFixedDelay1_RejectedExecutionException() throws InterruptedException { ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1); try { se.shutdown(); se.scheduleWithFixedDelay(new NoOpRunnable(), - MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS); shouldThrow(); - } catch(RejectedExecutionException success){ + } catch (RejectedExecutionException success) { } catch (SecurityException ok) { - } + } joinPool(se); } @@ -289,107 +247,91 @@ public class ScheduledExecutorTest extends JSR166TestCase { * getActiveCount increases but doesn't overestimate, when a * thread becomes active */ - public void testGetActiveCount() { + public void testGetActiveCount() throws InterruptedException { ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2); assertEquals(0, p2.getActiveCount()); p2.execute(new SmallRunnable()); - try { - Thread.sleep(SHORT_DELAY_MS); - } catch(Exception e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); assertEquals(1, p2.getActiveCount()); joinPool(p2); } - + /** * getCompletedTaskCount increases, but doesn't overestimate, * when tasks complete */ - public void testGetCompletedTaskCount() { + public void testGetCompletedTaskCount() throws InterruptedException { ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2); assertEquals(0, p2.getCompletedTaskCount()); p2.execute(new SmallRunnable()); - try { - Thread.sleep(MEDIUM_DELAY_MS); - } catch(Exception e){ - unexpectedException(); - } + Thread.sleep(MEDIUM_DELAY_MS); assertEquals(1, p2.getCompletedTaskCount()); joinPool(p2); } - + /** - * getCorePoolSize returns size given in constructor if not otherwise set + * getCorePoolSize returns size given in constructor if not otherwise set */ - public void testGetCorePoolSize() { + public void testGetCorePoolSize() throws InterruptedException { ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); assertEquals(1, p1.getCorePoolSize()); joinPool(p1); } - + /** * getLargestPoolSize increases, but doesn't overestimate, when * multiple threads active */ - public void testGetLargestPoolSize() { + public void testGetLargestPoolSize() throws InterruptedException { ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2); assertEquals(0, p2.getLargestPoolSize()); p2.execute(new SmallRunnable()); p2.execute(new SmallRunnable()); - try { - Thread.sleep(SHORT_DELAY_MS); - } catch(Exception e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); assertEquals(2, p2.getLargestPoolSize()); joinPool(p2); } - + /** * getPoolSize increases, but doesn't overestimate, when threads * become active */ - public void testGetPoolSize() { + public void testGetPoolSize() throws InterruptedException { ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); assertEquals(0, p1.getPoolSize()); p1.execute(new SmallRunnable()); assertEquals(1, p1.getPoolSize()); joinPool(p1); } - + /** * getTaskCount increases, but doesn't overestimate, when tasks * submitted */ - public void testGetTaskCount() { + public void testGetTaskCount() throws InterruptedException { ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); assertEquals(0, p1.getTaskCount()); - for(int i = 0; i < 5; i++) + for (int i = 0; i < 5; i++) p1.execute(new SmallRunnable()); - try { - Thread.sleep(SHORT_DELAY_MS); - } catch(Exception e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); assertEquals(5, p1.getTaskCount()); joinPool(p1); } - /** + /** * getThreadFactory returns factory in constructor if not set */ - public void testGetThreadFactory() { + public void testGetThreadFactory() throws InterruptedException { ThreadFactory tf = new SimpleThreadFactory(); ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1, tf); assertSame(tf, p.getThreadFactory()); joinPool(p); } - /** + /** * setThreadFactory sets the thread factory returned by getThreadFactory */ - public void testSetThreadFactory() { + public void testSetThreadFactory() throws InterruptedException { ThreadFactory tf = new SimpleThreadFactory(); ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1); p.setThreadFactory(tf); @@ -397,10 +339,10 @@ public class ScheduledExecutorTest extends JSR166TestCase { joinPool(p); } - /** + /** * setThreadFactory(null) throws NPE */ - public void testSetThreadFactoryNull() { + public void testSetThreadFactoryNull() throws InterruptedException { ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1); try { p.setThreadFactory(null); @@ -410,78 +352,69 @@ public class ScheduledExecutorTest extends JSR166TestCase { joinPool(p); } } - + /** * is isShutDown is false before shutdown, true after */ public void testIsShutdown() { - + ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); try { assertFalse(p1.isShutdown()); } finally { - try { p1.shutdown(); } catch(SecurityException ok) { return; } + try { p1.shutdown(); } catch (SecurityException ok) { return; } } assertTrue(p1.isShutdown()); } - + /** * isTerminated is false before termination, true after */ - public void testIsTerminated() { + public void testIsTerminated() throws InterruptedException { ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); try { p1.execute(new SmallRunnable()); } finally { - try { p1.shutdown(); } catch(SecurityException ok) { return; } + try { p1.shutdown(); } catch (SecurityException ok) { return; } } - try { - assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); - assertTrue(p1.isTerminated()); - } catch(Exception e){ - unexpectedException(); - } + assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue(p1.isTerminated()); } /** * isTerminating is not true when running or when terminated */ - public void testIsTerminating() { + public void testIsTerminating() throws InterruptedException { ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); assertFalse(p1.isTerminating()); try { p1.execute(new SmallRunnable()); assertFalse(p1.isTerminating()); } finally { - try { p1.shutdown(); } catch(SecurityException ok) { return; } + try { p1.shutdown(); } catch (SecurityException ok) { return; } } - try { - assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); - assertTrue(p1.isTerminated()); - assertFalse(p1.isTerminating()); - } catch(Exception e){ - unexpectedException(); - } + + assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue(p1.isTerminated()); + assertFalse(p1.isTerminating()); } /** * getQueue returns the work queue, which contains queued tasks */ - public void testGetQueue() { + public void testGetQueue() throws InterruptedException { ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); ScheduledFuture[] tasks = new ScheduledFuture[5]; - for(int i = 0; i < 5; i++){ - tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, TimeUnit.MILLISECONDS); + for (int i = 0; i < 5; i++) { + tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, MILLISECONDS); } try { Thread.sleep(SHORT_DELAY_MS); BlockingQueue<Runnable> q = p1.getQueue(); assertTrue(q.contains(tasks[4])); assertFalse(q.contains(tasks[0])); - } catch(Exception e) { - unexpectedException(); } finally { joinPool(p1); } @@ -490,11 +423,11 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * remove(task) removes queued task, and fails to remove active task */ - public void testRemove() { + public void testRemove() throws InterruptedException { ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); ScheduledFuture[] tasks = new ScheduledFuture[5]; - for(int i = 0; i < 5; i++){ - tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, TimeUnit.MILLISECONDS); + for (int i = 0; i < 5; i++) { + tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, MILLISECONDS); } try { Thread.sleep(SHORT_DELAY_MS); @@ -508,8 +441,6 @@ public class ScheduledExecutorTest extends JSR166TestCase { assertTrue(q.contains((Runnable)tasks[3])); assertTrue(p1.remove((Runnable)tasks[3])); assertFalse(q.contains((Runnable)tasks[3])); - } catch(Exception e) { - unexpectedException(); } finally { joinPool(p1); } @@ -518,11 +449,11 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * purge removes cancelled tasks from the queue */ - public void testPurge() { + public void testPurge() throws InterruptedException { ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); ScheduledFuture[] tasks = new ScheduledFuture[5]; - for(int i = 0; i < 5; i++){ - tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS); + for (int i = 0; i < 5; i++) { + tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS); } try { int max = 5; @@ -539,8 +470,6 @@ public class ScheduledExecutorTest extends JSR166TestCase { Thread.sleep(1); } assertTrue(k < SMALL_DELAY_MS); - } catch(Exception e) { - unexpectedException(); } finally { joinPool(p1); } @@ -549,14 +478,14 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * shutDownNow returns a list containing tasks that were not run */ - public void testShutDownNow() { + public void testShutDownNow() throws InterruptedException { ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); - for(int i = 0; i < 5; i++) - p1.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS); + for (int i = 0; i < 5; i++) + p1.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS); List l; try { l = p1.shutdownNow(); - } catch (SecurityException ok) { + } catch (SecurityException ok) { return; } assertTrue(p1.isShutdown()); @@ -568,31 +497,25 @@ public class ScheduledExecutorTest extends JSR166TestCase { * In default setting, shutdown cancels periodic but not delayed * tasks at shutdown */ - public void testShutDown1() { - try { - ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); - assertTrue(p1.getExecuteExistingDelayedTasksAfterShutdownPolicy()); - assertFalse(p1.getContinueExistingPeriodicTasksAfterShutdownPolicy()); - - ScheduledFuture[] tasks = new ScheduledFuture[5]; - for(int i = 0; i < 5; i++) - tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - try { p1.shutdown(); } catch(SecurityException ok) { return; } - BlockingQueue q = p1.getQueue(); - for (Iterator it = q.iterator(); it.hasNext();) { - ScheduledFuture t = (ScheduledFuture)it.next(); - assertFalse(t.isCancelled()); - } - assertTrue(p1.isShutdown()); - Thread.sleep(SMALL_DELAY_MS); - for (int i = 0; i < 5; ++i) { - assertTrue(tasks[i].isDone()); - assertFalse(tasks[i].isCancelled()); - } - + public void testShutDown1() throws InterruptedException { + ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); + assertTrue(p1.getExecuteExistingDelayedTasksAfterShutdownPolicy()); + assertFalse(p1.getContinueExistingPeriodicTasksAfterShutdownPolicy()); + + ScheduledFuture[] tasks = new ScheduledFuture[5]; + for (int i = 0; i < 5; i++) + tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, MILLISECONDS); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + BlockingQueue q = p1.getQueue(); + for (Iterator it = q.iterator(); it.hasNext();) { + ScheduledFuture t = (ScheduledFuture)it.next(); + assertFalse(t.isCancelled()); } - catch(Exception ex) { - unexpectedException(); + assertTrue(p1.isShutdown()); + Thread.sleep(SMALL_DELAY_MS); + for (int i = 0; i < 5; ++i) { + assertTrue(tasks[i].isDone()); + assertFalse(tasks[i].isCancelled()); } } @@ -601,23 +524,18 @@ public class ScheduledExecutorTest extends JSR166TestCase { * If setExecuteExistingDelayedTasksAfterShutdownPolicy is false, * delayed tasks are cancelled at shutdown */ - public void testShutDown2() { - try { - ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); - p1.setExecuteExistingDelayedTasksAfterShutdownPolicy(false); - ScheduledFuture[] tasks = new ScheduledFuture[5]; - for(int i = 0; i < 5; i++) - tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - try { p1.shutdown(); } catch(SecurityException ok) { return; } - assertTrue(p1.isShutdown()); - BlockingQueue q = p1.getQueue(); - assertTrue(q.isEmpty()); - Thread.sleep(SMALL_DELAY_MS); - assertTrue(p1.isTerminated()); - } - catch(Exception ex) { - unexpectedException(); - } + public void testShutDown2() throws InterruptedException { + ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); + p1.setExecuteExistingDelayedTasksAfterShutdownPolicy(false); + ScheduledFuture[] tasks = new ScheduledFuture[5]; + for (int i = 0; i < 5; i++) + tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, MILLISECONDS); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + assertTrue(p1.isShutdown()); + BlockingQueue q = p1.getQueue(); + assertTrue(q.isEmpty()); + Thread.sleep(SMALL_DELAY_MS); + assertTrue(p1.isTerminated()); } @@ -625,36 +543,31 @@ public class ScheduledExecutorTest extends JSR166TestCase { * If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false, * periodic tasks are not cancelled at shutdown */ - public void testShutDown3() { - try { - ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); - p1.setContinueExistingPeriodicTasksAfterShutdownPolicy(false); - ScheduledFuture task = - p1.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, TimeUnit.MILLISECONDS); - try { p1.shutdown(); } catch(SecurityException ok) { return; } - assertTrue(p1.isShutdown()); - BlockingQueue q = p1.getQueue(); - assertTrue(q.isEmpty()); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(p1.isTerminated()); - } - catch(Exception ex) { - unexpectedException(); - } + public void testShutDown3() throws InterruptedException { + ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); + p1.setContinueExistingPeriodicTasksAfterShutdownPolicy(false); + ScheduledFuture task = + p1.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, MILLISECONDS); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + assertTrue(p1.isShutdown()); + BlockingQueue q = p1.getQueue(); + assertTrue(q.isEmpty()); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(p1.isTerminated()); } /** * if setContinueExistingPeriodicTasksAfterShutdownPolicy is true, * periodic tasks are cancelled at shutdown */ - public void testShutDown4() { + public void testShutDown4() throws InterruptedException { ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1); try { p1.setContinueExistingPeriodicTasksAfterShutdownPolicy(true); ScheduledFuture task = - p1.scheduleAtFixedRate(new NoOpRunnable(), 1, 1, TimeUnit.MILLISECONDS); + p1.scheduleAtFixedRate(new NoOpRunnable(), 1, 1, MILLISECONDS); assertFalse(task.isCancelled()); - try { p1.shutdown(); } catch(SecurityException ok) { return; } + try { p1.shutdown(); } catch (SecurityException ok) { return; } assertFalse(task.isCancelled()); assertFalse(p1.isTerminated()); assertTrue(p1.isShutdown()); @@ -665,10 +578,7 @@ public class ScheduledExecutorTest extends JSR166TestCase { Thread.sleep(SHORT_DELAY_MS); assertTrue(p1.isTerminated()); } - catch(Exception ex) { - unexpectedException(); - } - finally { + finally { joinPool(p1); } } @@ -676,18 +586,12 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * completed submit of callable returns result */ - public void testSubmitCallable() { + public void testSubmitCallable() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { Future<String> future = e.submit(new StringTask()); String result = future.get(); assertSame(TEST_STRING, result); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); } finally { joinPool(e); } @@ -696,18 +600,12 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * completed submit of runnable returns successfully */ - public void testSubmitRunnable() { + public void testSubmitRunnable() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { Future<?> future = e.submit(new NoOpRunnable()); future.get(); assertTrue(future.isDone()); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); } finally { joinPool(e); } @@ -716,18 +614,12 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * completed submit of (runnable, result) returns result */ - public void testSubmitRunnable2() { + public void testSubmitRunnable2() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING); String result = future.get(); assertSame(TEST_STRING, result); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); } finally { joinPool(e); } @@ -736,13 +628,12 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * invokeAny(null) throws NPE */ - public void testInvokeAny1() { + public void testInvokeAny1() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { e.invokeAny(null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -751,13 +642,12 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * invokeAny(empty collection) throws IAE */ - public void testInvokeAny2() { + public void testInvokeAny2() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { e.invokeAny(new ArrayList<Callable<String>>()); + shouldThrow(); } catch (IllegalArgumentException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -766,17 +656,18 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * invokeAny(c) throws NPE if c has null elements */ - public void testInvokeAny3() { + public void testInvokeAny3() throws Exception { + CountDownLatch latch = new CountDownLatch(1); ExecutorService e = new ScheduledThreadPoolExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(latchAwaitingStringTask(latch)); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); e.invokeAny(l); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { + latch.countDown(); joinPool(e); } } @@ -784,15 +675,15 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * invokeAny(c) throws ExecutionException if no task completes */ - public void testInvokeAny4() { + public void testInvokeAny4() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new NPETask()); e.invokeAny(l); + shouldThrow(); } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -801,17 +692,14 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * invokeAny(c) returns result of some task */ - public void testInvokeAny5() { + public void testInvokeAny5() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); String result = e.invokeAny(l); assertSame(TEST_STRING, result); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -820,13 +708,12 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * invokeAll(null) throws NPE */ - public void testInvokeAll1() { + public void testInvokeAll1() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { e.invokeAll(null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -835,13 +722,11 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * invokeAll(empty collection) returns empty collection */ - public void testInvokeAll2() { + public void testInvokeAll2() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>()); assertTrue(r.isEmpty()); - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -850,16 +735,15 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * invokeAll(c) throws NPE if c has null elements */ - public void testInvokeAll3() { + public void testInvokeAll3() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); e.invokeAll(l); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -868,18 +752,17 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * get of invokeAll(c) throws exception on failed task */ - public void testInvokeAll4() { + public void testInvokeAll4() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); + List<Future<String>> futures = e.invokeAll(l); + assertEquals(1, futures.size()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new NPETask()); - List<Future<String>> result = e.invokeAll(l); - assertEquals(1, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - it.next().get(); - } catch(ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -888,19 +771,16 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * invokeAll(c) returns results of all completed tasks */ - public void testInvokeAll5() { + public void testInvokeAll5() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); - List<Future<String>> result = e.invokeAll(l); - assertEquals(2, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - assertSame(TEST_STRING, it.next().get()); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + List<Future<String>> futures = e.invokeAll(l); + assertEquals(2, futures.size()); + for (Future<String> future : futures) + assertSame(TEST_STRING, future.get()); } finally { joinPool(e); } @@ -909,13 +789,12 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAny(null) throws NPE */ - public void testTimedInvokeAny1() { + public void testTimedInvokeAny1() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { - e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -924,15 +803,14 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAny(,,null) throws NPE */ - public void testTimedInvokeAnyNullTimeUnit() { + public void testTimedInvokeAnyNullTimeUnit() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); e.invokeAny(l, MEDIUM_DELAY_MS, null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -941,13 +819,12 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAny(empty collection) throws IAE */ - public void testTimedInvokeAny2() { + public void testTimedInvokeAny2() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { - e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (IllegalArgumentException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -956,18 +833,18 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAny(c) throws NPE if c has null elements */ - public void testTimedInvokeAny3() { + public void testTimedInvokeAny3() throws Exception { + CountDownLatch latch = new CountDownLatch(1); ExecutorService e = new ScheduledThreadPoolExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(latchAwaitingStringTask(latch)); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); - e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { + latch.countDown(); joinPool(e); } } @@ -975,15 +852,15 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAny(c) throws ExecutionException if no task completes */ - public void testTimedInvokeAny4() { + public void testTimedInvokeAny4() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new NPETask()); - e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - } catch(ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -992,17 +869,14 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAny(c) returns result of some task */ - public void testTimedInvokeAny5() { + public void testTimedInvokeAny5() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); - String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); assertSame(TEST_STRING, result); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1011,13 +885,12 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAll(null) throws NPE */ - public void testTimedInvokeAll1() { + public void testTimedInvokeAll1() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { - e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1026,15 +899,14 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAll(,,null) throws NPE */ - public void testTimedInvokeAllNullTimeUnit() { + public void testTimedInvokeAllNullTimeUnit() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); e.invokeAll(l, MEDIUM_DELAY_MS, null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1043,13 +915,11 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAll(empty collection) returns empty collection */ - public void testTimedInvokeAll2() { + public void testTimedInvokeAll2() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { - List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); assertTrue(r.isEmpty()); - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1058,16 +928,15 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAll(c) throws NPE if c has null elements */ - public void testTimedInvokeAll3() { + public void testTimedInvokeAll3() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); - e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1076,18 +945,18 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * get of element of invokeAll(c) throws exception on failed task */ - public void testTimedInvokeAll4() { + public void testTimedInvokeAll4() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); + List<Future<String>> futures = + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertEquals(1, futures.size()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new NPETask()); - List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - assertEquals(1, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - it.next().get(); - } catch(ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -1096,19 +965,17 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAll(c) returns results of all completed tasks */ - public void testTimedInvokeAll5() { + public void testTimedInvokeAll5() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); - List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - assertEquals(2, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - assertSame(TEST_STRING, it.next().get()); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + List<Future<String>> futures = + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertEquals(2, futures.size()); + for (Future<String> future : futures) + assertSame(TEST_STRING, future.get()); } finally { joinPool(e); } @@ -1117,16 +984,17 @@ public class ScheduledExecutorTest extends JSR166TestCase { /** * timed invokeAll(c) cancels tasks not completed by timeout */ - public void testTimedInvokeAll6() { + public void testTimedInvokeAll6() throws Exception { ExecutorService e = new ScheduledThreadPoolExecutor(2); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING)); l.add(new StringTask()); - List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - assertEquals(3, result.size()); - Iterator<Future<String>> it = result.iterator(); + List<Future<String>> futures = + e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS); + assertEquals(3, futures.size()); + Iterator<Future<String>> it = futures.iterator(); Future<String> f1 = it.next(); Future<String> f2 = it.next(); Future<String> f3 = it.next(); @@ -1135,8 +1003,6 @@ public class ScheduledExecutorTest extends JSR166TestCase { assertTrue(f3.isDone()); assertFalse(f1.isCancelled()); assertTrue(f2.isCancelled()); - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/SemaphoreTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/SemaphoreTest.java index 3f2ff33..c27893c 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/SemaphoreTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/SemaphoreTest.java @@ -2,15 +2,16 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.io.*; public class SemaphoreTest extends JSR166TestCase { @@ -23,10 +24,10 @@ public class SemaphoreTest extends JSR166TestCase { */ static class PublicSemaphore extends Semaphore { PublicSemaphore(int p, boolean f) { super(p, f); } - public Collection<Thread> getQueuedThreads() { - return super.getQueuedThreads(); + public Collection<Thread> getQueuedThreads() { + return super.getQueuedThreads(); } - public void reducePermits(int p) { + public void reducePermits(int p) { super.reducePermits(p); } } @@ -34,29 +35,26 @@ public class SemaphoreTest extends JSR166TestCase { /** * A runnable calling acquire */ - class InterruptibleLockRunnable implements Runnable { + class InterruptibleLockRunnable extends CheckedRunnable { final Semaphore lock; InterruptibleLockRunnable(Semaphore l) { lock = l; } - public void run() { + public void realRun() { try { lock.acquire(); - } catch(InterruptedException success){} + } + catch (InterruptedException ignored) {} } } /** - * A runnable calling acquire that expects to be - * interrupted + * A runnable calling acquire that expects to be interrupted */ - class InterruptedLockRunnable implements Runnable { + class InterruptedLockRunnable extends CheckedInterruptedRunnable { final Semaphore lock; InterruptedLockRunnable(Semaphore l) { lock = l; } - public void run() { - try { - lock.acquire(); - threadShouldThrow(); - } catch(InterruptedException success){} + public void realRun() throws InterruptedException { + lock.acquire(); } } @@ -64,30 +62,24 @@ public class SemaphoreTest extends JSR166TestCase { * Zero, negative, and positive initial values are allowed in constructor */ public void testConstructor() { - Semaphore s0 = new Semaphore(0, false); - assertEquals(0, s0.availablePermits()); - assertFalse(s0.isFair()); - Semaphore s1 = new Semaphore(-1, false); - assertEquals(-1, s1.availablePermits()); - assertFalse(s1.isFair()); - Semaphore s2 = new Semaphore(-1, false); - assertEquals(-1, s2.availablePermits()); - assertFalse(s2.isFair()); + for (int permits : new int[] { -1, 0, 1 }) { + for (boolean fair : new boolean[] { false, true }) { + Semaphore s = new Semaphore(permits, fair); + assertEquals(permits, s.availablePermits()); + assertEquals(fair, s.isFair()); + } + } } /** * Constructor without fairness argument behaves as nonfair */ public void testConstructor2() { - Semaphore s0 = new Semaphore(0); - assertEquals(0, s0.availablePermits()); - assertFalse(s0.isFair()); - Semaphore s1 = new Semaphore(-1); - assertEquals(-1, s1.availablePermits()); - assertFalse(s1.isFair()); - Semaphore s2 = new Semaphore(-1); - assertEquals(-1, s2.availablePermits()); - assertFalse(s2.isFair()); + for (int permits : new int[] { -1, 0, 1 }) { + Semaphore s = new Semaphore(permits); + assertEquals(permits, s.availablePermits()); + assertFalse(s.isFair()); + } } /** @@ -105,296 +97,245 @@ public class SemaphoreTest extends JSR166TestCase { /** * Acquire and release of semaphore succeed if initially available */ - public void testAcquireReleaseInSameThread() { + public void testAcquireReleaseInSameThread() + throws InterruptedException { Semaphore s = new Semaphore(1, false); - try { - s.acquire(); - s.release(); - s.acquire(); - s.release(); - s.acquire(); - s.release(); - s.acquire(); - s.release(); - s.acquire(); - s.release(); - assertEquals(1, s.availablePermits()); - } catch( InterruptedException e){ - unexpectedException(); - } + s.acquire(); + s.release(); + s.acquire(); + s.release(); + s.acquire(); + s.release(); + s.acquire(); + s.release(); + s.acquire(); + s.release(); + assertEquals(1, s.availablePermits()); } /** * Uninterruptible acquire and release of semaphore succeed if * initially available */ - public void testAcquireUninterruptiblyReleaseInSameThread() { + public void testAcquireUninterruptiblyReleaseInSameThread() + throws InterruptedException { Semaphore s = new Semaphore(1, false); - try { - s.acquireUninterruptibly(); - s.release(); - s.acquireUninterruptibly(); - s.release(); - s.acquireUninterruptibly(); - s.release(); - s.acquireUninterruptibly(); - s.release(); - s.acquireUninterruptibly(); - s.release(); - assertEquals(1, s.availablePermits()); - } finally { - } + s.acquireUninterruptibly(); + s.release(); + s.acquireUninterruptibly(); + s.release(); + s.acquireUninterruptibly(); + s.release(); + s.acquireUninterruptibly(); + s.release(); + s.acquireUninterruptibly(); + s.release(); + assertEquals(1, s.availablePermits()); } /** * Timed Acquire and release of semaphore succeed if * initially available */ - public void testTimedAcquireReleaseInSameThread() { + public void testTimedAcquireReleaseInSameThread() + throws InterruptedException { Semaphore s = new Semaphore(1, false); - try { - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - assertEquals(1, s.availablePermits()); - } catch( InterruptedException e){ - unexpectedException(); - } + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertEquals(1, s.availablePermits()); } /** * A release in one thread enables an acquire in another thread */ - public void testAcquireReleaseInDifferentThreads() { + public void testAcquireReleaseInDifferentThreads() + throws InterruptedException { final Semaphore s = new Semaphore(0, false); - Thread t = new Thread(new Runnable() { - public void run() { - try { - s.acquire(); - s.release(); - s.release(); - s.acquire(); - } catch(InterruptedException ie){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - s.release(); - s.release(); - s.acquire(); - s.acquire(); - s.release(); - t.join(); - } catch( InterruptedException e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + s.acquire(); + s.release(); + s.release(); + s.acquire(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + s.release(); + s.release(); + s.acquire(); + s.acquire(); + s.release(); + t.join(); } /** * A release in one thread enables an uninterruptible acquire in another thread */ - public void testUninterruptibleAcquireReleaseInDifferentThreads() { + public void testUninterruptibleAcquireReleaseInDifferentThreads() + throws InterruptedException { final Semaphore s = new Semaphore(0, false); - Thread t = new Thread(new Runnable() { - public void run() { - s.acquireUninterruptibly(); - s.release(); - s.release(); - s.acquireUninterruptibly(); - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - s.release(); - s.release(); - s.acquireUninterruptibly(); - s.acquireUninterruptibly(); - s.release(); - t.join(); - } catch( InterruptedException e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + s.acquireUninterruptibly(); + s.release(); + s.release(); + s.acquireUninterruptibly(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + s.release(); + s.release(); + s.acquireUninterruptibly(); + s.acquireUninterruptibly(); + s.release(); + t.join(); } /** * A release in one thread enables a timed acquire in another thread */ - public void testTimedAcquireReleaseInDifferentThreads() { + public void testTimedAcquireReleaseInDifferentThreads() + throws InterruptedException { final Semaphore s = new Semaphore(1, false); - Thread t = new Thread(new Runnable() { - public void run() { - try { - s.release(); - threadAssertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - threadAssertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - - } catch(InterruptedException ie){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - s.release(); - t.join(); - } catch( InterruptedException e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + s.release(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + }}); + + t.start(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + s.release(); + t.join(); } /** * A waiting acquire blocks interruptibly */ - public void testAcquire_InterruptedException() { + public void testAcquire_InterruptedException() + throws InterruptedException { final Semaphore s = new Semaphore(0, false); - Thread t = new Thread(new Runnable() { - public void run() { - try { - s.acquire(); - threadShouldThrow(); - } catch(InterruptedException success){} - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + s.acquire(); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } - + /** * A waiting timed acquire blocks interruptibly */ - public void testTryAcquire_InterruptedException() { + public void testTryAcquire_InterruptedException() + throws InterruptedException { final Semaphore s = new Semaphore(0, false); - Thread t = new Thread(new Runnable() { - public void run() { - try { - s.tryAcquire(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(InterruptedException success){ - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + s.tryAcquire(MEDIUM_DELAY_MS, MILLISECONDS); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * hasQueuedThreads reports whether there are waiting threads */ - public void testHasQueuedThreads() { + public void testHasQueuedThreads() throws InterruptedException { final Semaphore lock = new Semaphore(1, false); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertFalse(lock.hasQueuedThreads()); - lock.acquireUninterruptibly(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); - lock.release(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(lock.hasQueuedThreads()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + assertFalse(lock.hasQueuedThreads()); + lock.acquireUninterruptibly(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.hasQueuedThreads()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.hasQueuedThreads()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.hasQueuedThreads()); + lock.release(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(lock.hasQueuedThreads()); + t1.join(); + t2.join(); + } /** * getQueueLength reports number of waiting threads */ - public void testGetQueueLength() { + public void testGetQueueLength() throws InterruptedException { final Semaphore lock = new Semaphore(1, false); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertEquals(0, lock.getQueueLength()); - lock.acquireUninterruptibly(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, lock.getQueueLength()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(2, lock.getQueueLength()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, lock.getQueueLength()); - lock.release(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(0, lock.getQueueLength()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + assertEquals(0, lock.getQueueLength()); + lock.acquireUninterruptibly(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, lock.getQueueLength()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(2, lock.getQueueLength()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, lock.getQueueLength()); + lock.release(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(0, lock.getQueueLength()); + t1.join(); + t2.join(); + } /** * getQueuedThreads includes waiting threads */ - public void testGetQueuedThreads() { + public void testGetQueuedThreads() throws InterruptedException { final PublicSemaphore lock = new PublicSemaphore(1, false); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertTrue(lock.getQueuedThreads().isEmpty()); - lock.acquireUninterruptibly(); - assertTrue(lock.getQueuedThreads().isEmpty()); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.getQueuedThreads().contains(t1)); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.getQueuedThreads().contains(t1)); - assertTrue(lock.getQueuedThreads().contains(t2)); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(lock.getQueuedThreads().contains(t1)); - assertTrue(lock.getQueuedThreads().contains(t2)); - lock.release(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.getQueuedThreads().isEmpty()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + assertTrue(lock.getQueuedThreads().isEmpty()); + lock.acquireUninterruptibly(); + assertTrue(lock.getQueuedThreads().isEmpty()); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.getQueuedThreads().contains(t1)); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.getQueuedThreads().contains(t1)); + assertTrue(lock.getQueuedThreads().contains(t2)); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertFalse(lock.getQueuedThreads().contains(t1)); + assertTrue(lock.getQueuedThreads().contains(t2)); + lock.release(); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(lock.getQueuedThreads().isEmpty()); + t1.join(); + t2.join(); + } /** * drainPermits reports and removes given number of permits @@ -425,26 +366,22 @@ public class SemaphoreTest extends JSR166TestCase { /** * a deserialized serialized semaphore has same number of permits */ - public void testSerialization() { + public void testSerialization() throws Exception { Semaphore l = new Semaphore(3, false); - try { - l.acquire(); - l.release(); - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - Semaphore r = (Semaphore) in.readObject(); - assertEquals(3, r.availablePermits()); - assertFalse(r.isFair()); - r.acquire(); - r.release(); - } catch(Exception e){ - unexpectedException(); - } + l.acquire(); + l.release(); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + Semaphore r = (Semaphore) in.readObject(); + assertEquals(3, r.availablePermits()); + assertFalse(r.isFair()); + r.acquire(); + r.release(); } @@ -487,45 +424,39 @@ public class SemaphoreTest extends JSR166TestCase { /** * Acquire and release of semaphore succeed if initially available */ - public void testAcquireReleaseInSameThread_fair() { + public void testAcquireReleaseInSameThread_fair() + throws InterruptedException { Semaphore s = new Semaphore(1, true); - try { - s.acquire(); - s.release(); - s.acquire(); - s.release(); - s.acquire(); - s.release(); - s.acquire(); - s.release(); - s.acquire(); - s.release(); - assertEquals(1, s.availablePermits()); - } catch( InterruptedException e){ - unexpectedException(); - } + s.acquire(); + s.release(); + s.acquire(); + s.release(); + s.acquire(); + s.release(); + s.acquire(); + s.release(); + s.acquire(); + s.release(); + assertEquals(1, s.availablePermits()); } /** * Acquire(n) and release(n) of semaphore succeed if initially available */ - public void testAcquireReleaseNInSameThread_fair() { + public void testAcquireReleaseNInSameThread_fair() + throws InterruptedException { Semaphore s = new Semaphore(1, true); - try { - s.release(1); - s.acquire(1); - s.release(2); - s.acquire(2); - s.release(3); - s.acquire(3); - s.release(4); - s.acquire(4); - s.release(5); - s.acquire(5); - assertEquals(1, s.availablePermits()); - } catch( InterruptedException e){ - unexpectedException(); - } + s.release(1); + s.acquire(1); + s.release(2); + s.acquire(2); + s.release(3); + s.acquire(3); + s.release(4); + s.acquire(4); + s.release(5); + s.acquire(5); + assertEquals(1, s.availablePermits()); } /** @@ -533,369 +464,287 @@ public class SemaphoreTest extends JSR166TestCase { */ public void testAcquireUninterruptiblyReleaseNInSameThread_fair() { Semaphore s = new Semaphore(1, true); - try { - s.release(1); - s.acquireUninterruptibly(1); - s.release(2); - s.acquireUninterruptibly(2); - s.release(3); - s.acquireUninterruptibly(3); - s.release(4); - s.acquireUninterruptibly(4); - s.release(5); - s.acquireUninterruptibly(5); - assertEquals(1, s.availablePermits()); - } finally { - } + s.release(1); + s.acquireUninterruptibly(1); + s.release(2); + s.acquireUninterruptibly(2); + s.release(3); + s.acquireUninterruptibly(3); + s.release(4); + s.acquireUninterruptibly(4); + s.release(5); + s.acquireUninterruptibly(5); + assertEquals(1, s.availablePermits()); } /** * release(n) in one thread enables timed acquire(n) in another thread */ - public void testTimedAcquireReleaseNInSameThread_fair() { + public void testTimedAcquireReleaseNInSameThread_fair() + throws InterruptedException { Semaphore s = new Semaphore(1, true); - try { - s.release(1); - assertTrue(s.tryAcquire(1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(2); - assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(3); - assertTrue(s.tryAcquire(3, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(4); - assertTrue(s.tryAcquire(4, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(5); - assertTrue(s.tryAcquire(5, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - assertEquals(1, s.availablePermits()); - } catch( InterruptedException e){ - unexpectedException(); - } + s.release(1); + assertTrue(s.tryAcquire(1, SHORT_DELAY_MS, MILLISECONDS)); + s.release(2); + assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, MILLISECONDS)); + s.release(3); + assertTrue(s.tryAcquire(3, SHORT_DELAY_MS, MILLISECONDS)); + s.release(4); + assertTrue(s.tryAcquire(4, SHORT_DELAY_MS, MILLISECONDS)); + s.release(5); + assertTrue(s.tryAcquire(5, SHORT_DELAY_MS, MILLISECONDS)); + assertEquals(1, s.availablePermits()); } /** * release in one thread enables timed acquire in another thread */ - public void testTimedAcquireReleaseInSameThread_fair() { + public void testTimedAcquireReleaseInSameThread_fair() + throws InterruptedException { Semaphore s = new Semaphore(1, true); - try { - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(); - assertEquals(1, s.availablePermits()); - } catch( InterruptedException e){ - unexpectedException(); - } + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + s.release(); + assertEquals(1, s.availablePermits()); } /** * A release in one thread enables an acquire in another thread */ - public void testAcquireReleaseInDifferentThreads_fair() { + public void testAcquireReleaseInDifferentThreads_fair() + throws InterruptedException { final Semaphore s = new Semaphore(0, true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - s.acquire(); - s.acquire(); - s.acquire(); - s.acquire(); - } catch(InterruptedException ie){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - s.release(); - s.release(); - s.release(); - s.release(); - s.release(); - s.release(); - t.join(); - assertEquals(2, s.availablePermits()); - } catch( InterruptedException e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + s.acquire(); + s.acquire(); + s.acquire(); + s.acquire(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + s.release(); + s.release(); + s.release(); + s.release(); + s.release(); + s.release(); + t.join(); + assertEquals(2, s.availablePermits()); } /** * release(n) in one thread enables acquire(n) in another thread */ - public void testAcquireReleaseNInDifferentThreads_fair() { + public void testAcquireReleaseNInDifferentThreads_fair() + throws InterruptedException { final Semaphore s = new Semaphore(0, true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - s.acquire(); - s.release(2); - s.acquire(); - } catch(InterruptedException ie){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - s.release(2); - s.acquire(2); - s.release(1); - t.join(); - } catch( InterruptedException e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + s.acquire(); + s.release(2); + s.acquire(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + s.release(2); + s.acquire(2); + s.release(1); + t.join(); } /** * release(n) in one thread enables acquire(n) in another thread */ - public void testAcquireReleaseNInDifferentThreads_fair2() { + public void testAcquireReleaseNInDifferentThreads_fair2() + throws InterruptedException { final Semaphore s = new Semaphore(0, true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - s.acquire(2); - s.acquire(2); - s.release(4); - } catch(InterruptedException ie){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - s.release(6); - s.acquire(2); - s.acquire(2); - s.release(2); - t.join(); - } catch( InterruptedException e){ - unexpectedException(); - } - } - - + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + s.acquire(2); + s.acquire(2); + s.release(4); + }}); + t.start(); + Thread.sleep(SHORT_DELAY_MS); + s.release(6); + s.acquire(2); + s.acquire(2); + s.release(2); + t.join(); + } /** * release in one thread enables timed acquire in another thread */ - public void testTimedAcquireReleaseInDifferentThreads_fair() { + public void testTimedAcquireReleaseInDifferentThreads_fair() + throws InterruptedException { final Semaphore s = new Semaphore(1, true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - - } catch(InterruptedException ie){ - threadUnexpectedException(); - } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + assertTrue(s.tryAcquire(SHORT_DELAY_MS, MILLISECONDS)); + }}); + t.start(); - try { - s.release(); - s.release(); - s.release(); - s.release(); - s.release(); - t.join(); - } catch( InterruptedException e){ - unexpectedException(); - } + s.release(); + s.release(); + s.release(); + s.release(); + s.release(); + t.join(); } /** * release(n) in one thread enables timed acquire(n) in another thread */ - public void testTimedAcquireReleaseNInDifferentThreads_fair() { + public void testTimedAcquireReleaseNInDifferentThreads_fair() + throws InterruptedException { final Semaphore s = new Semaphore(2, true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(2); - threadAssertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(2); - } catch(InterruptedException ie){ - threadUnexpectedException(); - } - } - }); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, MILLISECONDS)); + s.release(2); + assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, MILLISECONDS)); + s.release(2); + }}); + t.start(); - try { - assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(2); - assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - s.release(2); - t.join(); - } catch( InterruptedException e){ - unexpectedException(); - } + assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, MILLISECONDS)); + s.release(2); + assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, MILLISECONDS)); + s.release(2); + t.join(); } /** * A waiting acquire blocks interruptibly */ - public void testAcquire_InterruptedException_fair() { + public void testAcquire_InterruptedException_fair() + throws InterruptedException { final Semaphore s = new Semaphore(0, true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - s.acquire(); - threadShouldThrow(); - } catch(InterruptedException success){} - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + s.acquire(); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * A waiting acquire(n) blocks interruptibly */ - public void testAcquireN_InterruptedException_fair() { + public void testAcquireN_InterruptedException_fair() + throws InterruptedException { final Semaphore s = new Semaphore(2, true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - s.acquire(3); - threadShouldThrow(); - } catch(InterruptedException success){} - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + s.acquire(3); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } - + /** * A waiting tryAcquire blocks interruptibly */ - public void testTryAcquire_InterruptedException_fair() { + public void testTryAcquire_InterruptedException_fair() + throws InterruptedException { final Semaphore s = new Semaphore(0, true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - s.tryAcquire(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(InterruptedException success){ - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + s.tryAcquire(MEDIUM_DELAY_MS, MILLISECONDS); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * A waiting tryAcquire(n) blocks interruptibly */ - public void testTryAcquireN_InterruptedException_fair() { + public void testTryAcquireN_InterruptedException_fair() + throws InterruptedException { final Semaphore s = new Semaphore(1, true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - s.tryAcquire(4, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch(InterruptedException success){ - } - } - }); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + s.tryAcquire(4, MEDIUM_DELAY_MS, MILLISECONDS); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(InterruptedException e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * getQueueLength reports number of waiting threads */ - public void testGetQueueLength_fair() { + public void testGetQueueLength_fair() throws InterruptedException { final Semaphore lock = new Semaphore(1, true); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); - try { - assertEquals(0, lock.getQueueLength()); - lock.acquireUninterruptibly(); - t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, lock.getQueueLength()); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(2, lock.getQueueLength()); - t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, lock.getQueueLength()); - lock.release(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(0, lock.getQueueLength()); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } - } + assertEquals(0, lock.getQueueLength()); + lock.acquireUninterruptibly(); + t1.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, lock.getQueueLength()); + t2.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(2, lock.getQueueLength()); + t1.interrupt(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, lock.getQueueLength()); + lock.release(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(0, lock.getQueueLength()); + t1.join(); + t2.join(); + } /** * a deserialized serialized semaphore has same number of permits */ - public void testSerialization_fair() { + public void testSerialization_fair() throws Exception { Semaphore l = new Semaphore(3, true); - try { - l.acquire(); - l.release(); - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(l); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - Semaphore r = (Semaphore) in.readObject(); - assertEquals(3, r.availablePermits()); - assertTrue(r.isFair()); - r.acquire(); - r.release(); - } catch(Exception e){ - unexpectedException(); - } + l.acquire(); + l.release(); + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(l); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + Semaphore r = (Semaphore) in.readObject(); + assertEquals(3, r.availablePermits()); + assertTrue(r.isFair()); + r.acquire(); + r.release(); } /** diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/SynchronousQueueTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/SynchronousQueueTest.java index c2ae396..9393c5c 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/SynchronousQueueTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/SynchronousQueueTest.java @@ -2,15 +2,16 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.io.*; public class SynchronousQueueTest extends JSR166TestCase { @@ -48,7 +49,7 @@ public class SynchronousQueueTest extends JSR166TestCase { SynchronousQueue q = new SynchronousQueue(); q.offer(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -59,7 +60,7 @@ public class SynchronousQueueTest extends JSR166TestCase { SynchronousQueue q = new SynchronousQueue(); q.add(null); shouldThrow(); - } catch (NullPointerException success) { } + } catch (NullPointerException success) {} } /** @@ -79,8 +80,7 @@ public class SynchronousQueueTest extends JSR166TestCase { assertEquals(0, q.remainingCapacity()); q.add(one); shouldThrow(); - } catch (IllegalStateException success){ - } + } catch (IllegalStateException success) {} } /** @@ -91,8 +91,7 @@ public class SynchronousQueueTest extends JSR166TestCase { SynchronousQueue q = new SynchronousQueue(); q.addAll(null); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** @@ -103,8 +102,7 @@ public class SynchronousQueueTest extends JSR166TestCase { SynchronousQueue q = new SynchronousQueue(); q.addAll(q); shouldThrow(); - } - catch (IllegalArgumentException success) {} + } catch (IllegalArgumentException success) {} } /** @@ -116,8 +114,7 @@ public class SynchronousQueueTest extends JSR166TestCase { Integer[] ints = new Integer[1]; q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (NullPointerException success) {} + } catch (NullPointerException success) {} } /** * addAll throws ISE if no active taker @@ -130,243 +127,171 @@ public class SynchronousQueueTest extends JSR166TestCase { ints[i] = new Integer(i); q.addAll(Arrays.asList(ints)); shouldThrow(); - } - catch (IllegalStateException success) {} + } catch (IllegalStateException success) {} } /** * put(null) throws NPE */ - public void testPutNull() { + public void testPutNull() throws InterruptedException { try { SynchronousQueue q = new SynchronousQueue(); q.put(null); shouldThrow(); - } - catch (NullPointerException success){ - } - catch (InterruptedException ie) { - unexpectedException(); - } + } catch (NullPointerException success) {} } /** * put blocks interruptibly if no active taker */ - public void testBlockingPut() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - SynchronousQueue q = new SynchronousQueue(); - q.put(zero); - threadShouldThrow(); - } catch (InterruptedException ie){ - } - }}); + public void testBlockingPut() throws InterruptedException { + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + SynchronousQueue q = new SynchronousQueue(); + q.put(zero); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** - * put blocks waiting for take + * put blocks waiting for take */ - public void testPutWithTake() { + public void testPutWithTake() throws InterruptedException { final SynchronousQueue q = new SynchronousQueue(); - Thread t = new Thread(new Runnable() { - public void run() { - int added = 0; - try { - q.put(new Object()); - ++added; - q.put(new Object()); - ++added; - q.put(new Object()); - ++added; - q.put(new Object()); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + int added = 0; + try { + while (true) { + q.put(added); ++added; - threadShouldThrow(); - } catch (InterruptedException e){ - assertTrue(added >= 1); } + } catch (InterruptedException success) { + assertTrue(added == 1); } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - q.take(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(0, q.take()); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * timed offer times out if elements not taken */ - public void testTimedOffer() { + public void testTimedOffer() throws InterruptedException { final SynchronousQueue q = new SynchronousQueue(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - - threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch (InterruptedException success){} - } - }); - - try { - t.start(); - Thread.sleep(SMALL_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS)); + q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS); + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + t.interrupt(); + t.join(); } /** * take blocks interruptibly when empty */ - public void testTakeFromEmpty() { + public void testTakeFromEmpty() throws InterruptedException { final SynchronousQueue q = new SynchronousQueue(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.take(); - threadShouldThrow(); - } catch (InterruptedException success){ } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + q.take(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * put blocks interruptibly if no active taker */ - public void testFairBlockingPut() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - SynchronousQueue q = new SynchronousQueue(true); - q.put(zero); - threadShouldThrow(); - } catch (InterruptedException ie){ - } - }}); + public void testFairBlockingPut() throws InterruptedException { + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + SynchronousQueue q = new SynchronousQueue(true); + q.put(zero); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** - * put blocks waiting for take + * put blocks waiting for take */ - public void testFairPutWithTake() { + public void testFairPutWithTake() throws InterruptedException { final SynchronousQueue q = new SynchronousQueue(true); - Thread t = new Thread(new Runnable() { - public void run() { - int added = 0; - try { - q.put(new Object()); - ++added; - q.put(new Object()); - ++added; - q.put(new Object()); - ++added; - q.put(new Object()); + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + int added = 0; + try { + while (true) { + q.put(added); ++added; - threadShouldThrow(); - } catch (InterruptedException e){ - assertTrue(added >= 1); } + } catch (InterruptedException success) { + assertTrue(added == 1); } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - q.take(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(0, q.take()); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * timed offer times out if elements not taken */ - public void testFairTimedOffer() { + public void testFairTimedOffer() throws InterruptedException { final SynchronousQueue q = new SynchronousQueue(true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - - threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch (InterruptedException success){} - } - }); - - try { - t.start(); - Thread.sleep(SMALL_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS)); + q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS); + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + t.interrupt(); + t.join(); } /** * take blocks interruptibly when empty */ - public void testFairTakeFromEmpty() { + public void testFairTakeFromEmpty() throws InterruptedException { final SynchronousQueue q = new SynchronousQueue(true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.take(); - threadShouldThrow(); - } catch (InterruptedException success){ } - } - }); - try { - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + q.take(); + }}); + + t.start(); + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** @@ -380,128 +305,98 @@ public class SynchronousQueueTest extends JSR166TestCase { /** * timed pool with zero timeout times out if no active taker */ - public void testTimedPoll0() { - try { - SynchronousQueue q = new SynchronousQueue(); - assertNull(q.poll(0, TimeUnit.MILLISECONDS)); - } catch (InterruptedException e){ - unexpectedException(); - } + public void testTimedPoll0() throws InterruptedException { + SynchronousQueue q = new SynchronousQueue(); + assertNull(q.poll(0, MILLISECONDS)); } /** * timed pool with nonzero timeout times out if no active taker */ - public void testTimedPoll() { - try { - SynchronousQueue q = new SynchronousQueue(); - assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (InterruptedException e){ - unexpectedException(); - } + public void testTimedPoll() throws InterruptedException { + SynchronousQueue q = new SynchronousQueue(); + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); } /** * Interrupted timed poll throws InterruptedException instead of * returning timeout status */ - public void testInterruptedTimedPoll() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - SynchronousQueue q = new SynchronousQueue(); - assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (InterruptedException success){ - } - }}); + public void testInterruptedTimedPoll() throws InterruptedException { + final SynchronousQueue q = new SynchronousQueue(); + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + q.poll(SMALL_DELAY_MS, MILLISECONDS); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * timed poll before a delayed offer fails; after offer succeeds; * on interruption throws */ - public void testTimedPollWithOffer() { + public void testTimedPollWithOffer() throws InterruptedException { final SynchronousQueue q = new SynchronousQueue(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch (InterruptedException success) { } - } - }); - try { - t.start(); - Thread.sleep(SMALL_DELAY_MS); - assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); + assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS)); + try { + q.poll(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS)); + t.interrupt(); + t.join(); + } /** * Interrupted timed poll throws InterruptedException instead of * returning timeout status */ - public void testFairInterruptedTimedPoll() { - Thread t = new Thread(new Runnable() { - public void run() { - try { - SynchronousQueue q = new SynchronousQueue(true); - assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch (InterruptedException success){ - } - }}); + public void testFairInterruptedTimedPoll() throws InterruptedException { + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + SynchronousQueue q = new SynchronousQueue(true); + q.poll(SMALL_DELAY_MS, MILLISECONDS); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } - catch (InterruptedException ie) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** * timed poll before a delayed offer fails; after offer succeeds; * on interruption throws */ - public void testFairTimedPollWithOffer() { + public void testFairTimedPollWithOffer() throws InterruptedException { final SynchronousQueue q = new SynchronousQueue(true); - Thread t = new Thread(new Runnable() { - public void run() { - try { - threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS); - threadShouldThrow(); - } catch (InterruptedException success) { } - } - }); - try { - t.start(); - Thread.sleep(SMALL_DELAY_MS); - assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); - t.interrupt(); - t.join(); - } catch (Exception e){ - unexpectedException(); - } - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); + assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS)); + try { + q.poll(LONG_DELAY_MS, MILLISECONDS); + threadShouldThrow(); + } catch (InterruptedException success) {} + }}); + + t.start(); + Thread.sleep(SMALL_DELAY_MS); + assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS)); + t.interrupt(); + t.join(); + } /** @@ -520,8 +415,7 @@ public class SynchronousQueueTest extends JSR166TestCase { try { q.element(); shouldThrow(); - } - catch (NoSuchElementException success) {} + } catch (NoSuchElementException success) {} } /** @@ -532,8 +426,7 @@ public class SynchronousQueueTest extends JSR166TestCase { try { q.remove(); shouldThrow(); - } catch (NoSuchElementException success){ - } + } catch (NoSuchElementException success) {} } /** @@ -544,7 +437,7 @@ public class SynchronousQueueTest extends JSR166TestCase { assertFalse(q.remove(zero)); assertTrue(q.isEmpty()); } - + /** * contains returns false */ @@ -613,16 +506,16 @@ public class SynchronousQueueTest extends JSR166TestCase { Integer[] ints = new Integer[1]; assertNull(ints[0]); } - + /** * toArray(null) throws NPE */ public void testToArray_BadArg() { + SynchronousQueue q = new SynchronousQueue(); try { - SynchronousQueue q = new SynchronousQueue(); Object o[] = q.toArray(null); shouldThrow(); - } catch(NullPointerException success){} + } catch (NullPointerException success) {} } @@ -636,8 +529,7 @@ public class SynchronousQueueTest extends JSR166TestCase { try { Object x = it.next(); shouldThrow(); - } - catch (NoSuchElementException success) {} + } catch (NoSuchElementException success) {} } /** @@ -649,8 +541,9 @@ public class SynchronousQueueTest extends JSR166TestCase { try { it.remove(); shouldThrow(); + } catch (IllegalStateException success) { + } catch (UnsupportedOperationException success) { // android-added } - catch (IllegalStateException success) {} } /** @@ -660,7 +553,7 @@ public class SynchronousQueueTest extends JSR166TestCase { SynchronousQueue q = new SynchronousQueue(); String s = q.toString(); assertNotNull(s); - } + } /** @@ -669,35 +562,21 @@ public class SynchronousQueueTest extends JSR166TestCase { public void testOfferInExecutor() { final SynchronousQueue q = new SynchronousQueue(); ExecutorService executor = Executors.newFixedThreadPool(2); - final Integer one = new Integer(1); - executor.execute(new Runnable() { - public void run() { - threadAssertFalse(q.offer(one)); - try { - threadAssertTrue(q.offer(one, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertEquals(0, q.remainingCapacity()); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertFalse(q.offer(one)); + assertTrue(q.offer(one, MEDIUM_DELAY_MS, MILLISECONDS)); + assertEquals(0, q.remainingCapacity()); + }}); - executor.execute(new Runnable() { - public void run() { - try { - Thread.sleep(SMALL_DELAY_MS); - threadAssertEquals(one, q.take()); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); - - joinPool(executor); + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); + assertSame(one, q.take()); + }}); + joinPool(executor); } /** @@ -706,84 +585,65 @@ public class SynchronousQueueTest extends JSR166TestCase { public void testPollInExecutor() { final SynchronousQueue q = new SynchronousQueue(); ExecutorService executor = Executors.newFixedThreadPool(2); - executor.execute(new Runnable() { - public void run() { - threadAssertNull(q.poll()); - try { - threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS)); - threadAssertTrue(q.isEmpty()); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + assertNull(q.poll()); + assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS)); + assertTrue(q.isEmpty()); + }}); + + executor.execute(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(SHORT_DELAY_MS); + q.put(one); + }}); - executor.execute(new Runnable() { - public void run() { - try { - Thread.sleep(SMALL_DELAY_MS); - q.put(new Integer(1)); - } - catch (InterruptedException e) { - threadUnexpectedException(); - } - } - }); - joinPool(executor); } /** * a deserialized serialized queue is usable */ - public void testSerialization() { + public void testSerialization() throws Exception { SynchronousQueue q = new SynchronousQueue(); - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(q); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - SynchronousQueue r = (SynchronousQueue)in.readObject(); - assertEquals(q.size(), r.size()); - while (!q.isEmpty()) - assertEquals(q.remove(), r.remove()); - } catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + SynchronousQueue r = (SynchronousQueue)in.readObject(); + assertEquals(q.size(), r.size()); + while (!q.isEmpty()) + assertEquals(q.remove(), r.remove()); } /** * drainTo(null) throws NPE - */ + */ public void testDrainToNull() { SynchronousQueue q = new SynchronousQueue(); try { q.drainTo(null); shouldThrow(); - } catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * drainTo(this) throws IAE - */ + */ public void testDrainToSelf() { SynchronousQueue q = new SynchronousQueue(); try { q.drainTo(q); shouldThrow(); - } catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } /** * drainTo(c) of empty queue doesn't transfer elements - */ + */ public void testDrainTo() { SynchronousQueue q = new SynchronousQueue(); ArrayList l = new ArrayList(); @@ -794,98 +654,74 @@ public class SynchronousQueueTest extends JSR166TestCase { /** * drainTo empties queue, unblocking a waiting put. - */ - public void testDrainToWithActivePut() { + */ + public void testDrainToWithActivePut() throws InterruptedException { final SynchronousQueue q = new SynchronousQueue(); - Thread t = new Thread(new Runnable() { - public void run() { - try { - q.put(new Integer(1)); - } catch (InterruptedException ie){ - threadUnexpectedException(); - } - } - }); - try { - t.start(); - ArrayList l = new ArrayList(); - Thread.sleep(SHORT_DELAY_MS); - q.drainTo(l); - assertTrue(l.size() <= 1); - if (l.size() > 0) - assertEquals(l.get(0), new Integer(1)); - t.join(); - assertTrue(l.size() <= 1); - } catch(Exception e){ - unexpectedException(); - } + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.put(new Integer(1)); + }}); + + t.start(); + ArrayList l = new ArrayList(); + Thread.sleep(SHORT_DELAY_MS); + q.drainTo(l); + assertTrue(l.size() <= 1); + if (l.size() > 0) + assertEquals(l.get(0), new Integer(1)); + t.join(); + assertTrue(l.size() <= 1); } /** * drainTo(null, n) throws NPE - */ + */ public void testDrainToNullN() { SynchronousQueue q = new SynchronousQueue(); try { q.drainTo(null, 0); shouldThrow(); - } catch(NullPointerException success) { - } + } catch (NullPointerException success) {} } /** * drainTo(this, n) throws IAE - */ + */ public void testDrainToSelfN() { SynchronousQueue q = new SynchronousQueue(); try { q.drainTo(q, 0); shouldThrow(); - } catch(IllegalArgumentException success) { - } + } catch (IllegalArgumentException success) {} } /** * drainTo(c, n) empties up to n elements of queue into c - */ - public void testDrainToN() { + */ + public void testDrainToN() throws InterruptedException { final SynchronousQueue q = new SynchronousQueue(); - Thread t1 = new Thread(new Runnable() { - public void run() { - try { - q.put(one); - } catch (InterruptedException ie){ - threadUnexpectedException(); - } - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - try { - q.put(two); - } catch (InterruptedException ie){ - threadUnexpectedException(); - } - } - }); - - try { - t1.start(); - t2.start(); - ArrayList l = new ArrayList(); - Thread.sleep(SHORT_DELAY_MS); - q.drainTo(l, 1); - assertTrue(l.size() == 1); - q.drainTo(l, 1); - assertTrue(l.size() == 2); - assertTrue(l.contains(one)); - assertTrue(l.contains(two)); - t1.join(); - t2.join(); - } catch(Exception e){ - unexpectedException(); - } + Thread t1 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.put(one); + }}); + + Thread t2 = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + q.put(two); + }}); + + t1.start(); + t2.start(); + ArrayList l = new ArrayList(); + Thread.sleep(SHORT_DELAY_MS); + q.drainTo(l, 1); + assertTrue(l.size() == 1); + q.drainTo(l, 1); + assertTrue(l.size() == 2); + assertTrue(l.contains(one)); + assertTrue(l.contains(two)); + t1.join(); + t2.join(); } - } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/SystemTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/SystemTest.java index 439039a..e906186 100644 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/SystemTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/SystemTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; @@ -15,9 +15,9 @@ public class SystemTest extends JSR166TestCase { return new TestSuite(SystemTest.class); } - /** + /** * Worst case rounding for millisecs; set for 60 cycle millis clock. - * This value might need to be changed os JVMs with coarser + * This value might need to be changed on JVMs with coarser * System.currentTimeMillis clocks. */ static final long MILLIS_ROUND = 17; @@ -27,24 +27,19 @@ public class SystemTest extends JSR166TestCase { * possible rounding). * This shows only that nano timing not (much) worse than milli. */ - public void testNanoTime1() { - try { - long m1 = System.currentTimeMillis(); - Thread.sleep(1); - long n1 = System.nanoTime(); - Thread.sleep(SHORT_DELAY_MS); - long n2 = System.nanoTime(); - Thread.sleep(1); - long m2 = System.currentTimeMillis(); - long millis = m2 - m1; - long nanos = n2 - n1; - assertTrue(nanos >= 0); - long nanosAsMillis = nanos / 1000000; - assertTrue(nanosAsMillis <= millis + MILLIS_ROUND); - } - catch(InterruptedException ie) { - unexpectedException(); - } + public void testNanoTime1() throws InterruptedException { + long m1 = System.currentTimeMillis(); + Thread.sleep(1); + long n1 = System.nanoTime(); + Thread.sleep(SHORT_DELAY_MS); + long n2 = System.nanoTime(); + Thread.sleep(1); + long m2 = System.currentTimeMillis(); + long millis = m2 - m1; + long nanos = n2 - n1; + assertTrue(nanos >= 0); + long nanosAsMillis = nanos / 1000000; + assertTrue(nanosAsMillis <= millis + MILLIS_ROUND); } /** @@ -52,26 +47,20 @@ public class SystemTest extends JSR166TestCase { * for rounding. * This shows only that nano timing not (much) worse than milli. */ - public void testNanoTime2() { - try { - long n1 = System.nanoTime(); - Thread.sleep(1); - long m1 = System.currentTimeMillis(); - Thread.sleep(SHORT_DELAY_MS); - long m2 = System.currentTimeMillis(); - Thread.sleep(1); - long n2 = System.nanoTime(); - long millis = m2 - m1; - long nanos = n2 - n1; - - assertTrue(nanos >= 0); - long nanosAsMillis = nanos / 1000000; - assertTrue(millis <= nanosAsMillis + MILLIS_ROUND); - } - catch(InterruptedException ie) { - unexpectedException(); - } + public void testNanoTime2() throws InterruptedException { + long n1 = System.nanoTime(); + Thread.sleep(1); + long m1 = System.currentTimeMillis(); + Thread.sleep(SHORT_DELAY_MS); + long m2 = System.currentTimeMillis(); + Thread.sleep(1); + long n2 = System.nanoTime(); + long millis = m2 - m1; + long nanos = n2 - n1; + + assertTrue(nanos >= 0); + long nanosAsMillis = nanos / 1000000; + assertTrue(millis <= nanosAsMillis + MILLIS_ROUND); } } - diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadLocalTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadLocalTest.java index b9b7ba5..d54bce0 100644 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadLocalTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadLocalTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.Semaphore; @@ -27,7 +27,7 @@ public class ThreadLocalTest extends JSR166TestCase { protected Integer initialValue() { return zero; } - + protected Integer childValue(Integer parentValue) { return new Integer(parentValue.intValue() + 1); } @@ -37,11 +37,11 @@ public class ThreadLocalTest extends JSR166TestCase { * remove causes next access to return initial value */ public void testRemove() { - assertEquals(tl.get(), one); + assertSame(tl.get(), one); tl.set(two); - assertEquals(tl.get(), two); + assertSame(tl.get(), two); tl.remove(); - assertEquals(tl.get(), one); + assertSame(tl.get(), one); } /** @@ -49,11 +49,11 @@ public class ThreadLocalTest extends JSR166TestCase { * initial value */ public void testRemoveITL() { - assertEquals(itl.get(), zero); + assertSame(itl.get(), zero); itl.set(two); - assertEquals(itl.get(), two); + assertSame(itl.get(), two); itl.remove(); - assertEquals(itl.get(), zero); + assertSame(itl.get(), zero); } private class ITLThread extends Thread { @@ -66,18 +66,18 @@ public class ThreadLocalTest extends JSR166TestCase { child.start(); } Thread.currentThread().yield(); - + int threadId = itl.get().intValue(); for (int j = 0; j < threadId; j++) { x[threadId]++; Thread.currentThread().yield(); } - + if (child != null) { // Wait for child (if any) try { child.join(); - } catch(InterruptedException e) { - threadUnexpectedException(); + } catch (InterruptedException e) { + threadUnexpectedException(e); } } } @@ -86,19 +86,14 @@ public class ThreadLocalTest extends JSR166TestCase { /** * InheritableThreadLocal propagates generic values. */ - public void testGenericITL() { + public void testGenericITL() throws InterruptedException { final int threadCount = 10; final int x[] = new int[threadCount]; Thread progenitor = new ITLThread(x); - try { - progenitor.start(); - progenitor.join(); - for(int i = 0; i < threadCount; i++) { - assertEquals(i, x[i]); - } - } catch(InterruptedException e) { - unexpectedException(); + progenitor.start(); + progenitor.join(); + for (int i = 0; i < threadCount; i++) { + assertEquals(i, x[i]); } } } - diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadPoolExecutorSubclassTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadPoolExecutorSubclassTest.java new file mode 100644 index 0000000..911a35f --- /dev/null +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadPoolExecutorSubclassTest.java @@ -0,0 +1,1578 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. + */ + +package tests.api.java.util.concurrent; // android-added + +import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; +import java.util.concurrent.locks.*; + +import junit.framework.*; +import java.util.*; + +public class ThreadPoolExecutorSubclassTest extends JSR166TestCase { + public static Test suite() { + return new TestSuite(ThreadPoolExecutorSubclassTest.class); + } + + static class CustomTask<V> implements RunnableFuture<V> { + final Callable<V> callable; + final ReentrantLock lock = new ReentrantLock(); + final Condition cond = lock.newCondition(); + boolean done; + boolean cancelled; + V result; + Thread thread; + Exception exception; + CustomTask(Callable<V> c) { + if (c == null) throw new NullPointerException(); + callable = c; + } + CustomTask(final Runnable r, final V res) { + if (r == null) throw new NullPointerException(); + callable = new Callable<V>() { + public V call() throws Exception { r.run(); return res; }}; + } + public boolean isDone() { + lock.lock(); try { return done; } finally { lock.unlock() ; } + } + public boolean isCancelled() { + lock.lock(); try { return cancelled; } finally { lock.unlock() ; } + } + public boolean cancel(boolean mayInterrupt) { + lock.lock(); + try { + if (!done) { + cancelled = true; + done = true; + if (mayInterrupt && thread != null) + thread.interrupt(); + return true; + } + return false; + } + finally { lock.unlock() ; } + } + public void run() { + boolean runme; + lock.lock(); + try { + runme = !done; + if (!runme) + thread = Thread.currentThread(); + } + finally { lock.unlock() ; } + if (!runme) return; + V v = null; + Exception e = null; + try { + v = callable.call(); + } + catch (Exception ex) { + e = ex; + } + lock.lock(); + try { + result = v; + exception = e; + done = true; + thread = null; + cond.signalAll(); + } + finally { lock.unlock(); } + } + public V get() throws InterruptedException, ExecutionException { + lock.lock(); + try { + while (!done) + cond.await(); + if (exception != null) + throw new ExecutionException(exception); + return result; + } + finally { lock.unlock(); } + } + public V get(long timeout, TimeUnit unit) + throws InterruptedException, ExecutionException, TimeoutException { + long nanos = unit.toNanos(timeout); + lock.lock(); + try { + for (;;) { + if (done) break; + if (nanos < 0) + throw new TimeoutException(); + nanos = cond.awaitNanos(nanos); + } + if (exception != null) + throw new ExecutionException(exception); + return result; + } + finally { lock.unlock(); } + } + } + + + static class CustomTPE extends ThreadPoolExecutor { + protected <V> RunnableFuture<V> newTaskFor(Callable<V> c) { + return new CustomTask<V>(c); + } + protected <V> RunnableFuture<V> newTaskFor(Runnable r, V v) { + return new CustomTask<V>(r, v); + } + + CustomTPE(int corePoolSize, + int maximumPoolSize, + long keepAliveTime, + TimeUnit unit, + BlockingQueue<Runnable> workQueue) { + super(corePoolSize, maximumPoolSize, keepAliveTime, unit, + workQueue); + } + CustomTPE(int corePoolSize, + int maximumPoolSize, + long keepAliveTime, + TimeUnit unit, + BlockingQueue<Runnable> workQueue, + ThreadFactory threadFactory) { + super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, + threadFactory); + } + + CustomTPE(int corePoolSize, + int maximumPoolSize, + long keepAliveTime, + TimeUnit unit, + BlockingQueue<Runnable> workQueue, + RejectedExecutionHandler handler) { + super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, + handler); + } + CustomTPE(int corePoolSize, + int maximumPoolSize, + long keepAliveTime, + TimeUnit unit, + BlockingQueue<Runnable> workQueue, + ThreadFactory threadFactory, + RejectedExecutionHandler handler) { + super(corePoolSize, maximumPoolSize, keepAliveTime, unit, + workQueue, threadFactory, handler); + } + + volatile boolean beforeCalled = false; + volatile boolean afterCalled = false; + volatile boolean terminatedCalled = false; + public CustomTPE() { + super(1, 1, LONG_DELAY_MS, MILLISECONDS, new SynchronousQueue<Runnable>()); + } + protected void beforeExecute(Thread t, Runnable r) { + beforeCalled = true; + } + protected void afterExecute(Runnable r, Throwable t) { + afterCalled = true; + } + protected void terminated() { + terminatedCalled = true; + } + + } + + static class FailingThreadFactory implements ThreadFactory { + int calls = 0; + public Thread newThread(Runnable r) { + if (++calls > 1) return null; + return new Thread(r); + } + } + + + /** + * execute successfully executes a runnable + */ + public void testExecute() throws InterruptedException { + ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + p1.execute(new ShortRunnable()); + Thread.sleep(SMALL_DELAY_MS); + } finally { + joinPool(p1); + } + } + + /** + * getActiveCount increases but doesn't overestimate, when a + * thread becomes active + */ + public void testGetActiveCount() throws InterruptedException { + ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(0, p2.getActiveCount()); + p2.execute(new MediumRunnable()); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, p2.getActiveCount()); + joinPool(p2); + } + + /** + * prestartCoreThread starts a thread if under corePoolSize, else doesn't + */ + public void testPrestartCoreThread() { + ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(0, p2.getPoolSize()); + assertTrue(p2.prestartCoreThread()); + assertEquals(1, p2.getPoolSize()); + assertTrue(p2.prestartCoreThread()); + assertEquals(2, p2.getPoolSize()); + assertFalse(p2.prestartCoreThread()); + assertEquals(2, p2.getPoolSize()); + joinPool(p2); + } + + /** + * prestartAllCoreThreads starts all corePoolSize threads + */ + public void testPrestartAllCoreThreads() { + ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(0, p2.getPoolSize()); + p2.prestartAllCoreThreads(); + assertEquals(2, p2.getPoolSize()); + p2.prestartAllCoreThreads(); + assertEquals(2, p2.getPoolSize()); + joinPool(p2); + } + + /** + * getCompletedTaskCount increases, but doesn't overestimate, + * when tasks complete + */ + public void testGetCompletedTaskCount() throws InterruptedException { + ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(0, p2.getCompletedTaskCount()); + p2.execute(new ShortRunnable()); + Thread.sleep(SMALL_DELAY_MS); + assertEquals(1, p2.getCompletedTaskCount()); + try { p2.shutdown(); } catch (SecurityException ok) { return; } + joinPool(p2); + } + + /** + * getCorePoolSize returns size given in constructor if not otherwise set + */ + public void testGetCorePoolSize() { + ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(1, p1.getCorePoolSize()); + joinPool(p1); + } + + /** + * getKeepAliveTime returns value given in constructor if not otherwise set + */ + public void testGetKeepAliveTime() { + ThreadPoolExecutor p2 = new CustomTPE(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(1, p2.getKeepAliveTime(TimeUnit.SECONDS)); + joinPool(p2); + } + + + /** + * getThreadFactory returns factory in constructor if not set + */ + public void testGetThreadFactory() { + ThreadFactory tf = new SimpleThreadFactory(); + ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler()); + assertSame(tf, p.getThreadFactory()); + joinPool(p); + } + + /** + * setThreadFactory sets the thread factory returned by getThreadFactory + */ + public void testSetThreadFactory() { + ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadFactory tf = new SimpleThreadFactory(); + p.setThreadFactory(tf); + assertSame(tf, p.getThreadFactory()); + joinPool(p); + } + + + /** + * setThreadFactory(null) throws NPE + */ + public void testSetThreadFactoryNull() { + ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + p.setThreadFactory(null); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(p); + } + } + + /** + * getRejectedExecutionHandler returns handler in constructor if not set + */ + public void testGetRejectedExecutionHandler() { + RejectedExecutionHandler h = new NoOpREHandler(); + ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h); + assertSame(h, p.getRejectedExecutionHandler()); + joinPool(p); + } + + /** + * setRejectedExecutionHandler sets the handler returned by + * getRejectedExecutionHandler + */ + public void testSetRejectedExecutionHandler() { + ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + RejectedExecutionHandler h = new NoOpREHandler(); + p.setRejectedExecutionHandler(h); + assertSame(h, p.getRejectedExecutionHandler()); + joinPool(p); + } + + + /** + * setRejectedExecutionHandler(null) throws NPE + */ + public void testSetRejectedExecutionHandlerNull() { + ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + p.setRejectedExecutionHandler(null); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(p); + } + } + + + /** + * getLargestPoolSize increases, but doesn't overestimate, when + * multiple threads active + */ + public void testGetLargestPoolSize() throws InterruptedException { + ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(0, p2.getLargestPoolSize()); + p2.execute(new MediumRunnable()); + p2.execute(new MediumRunnable()); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(2, p2.getLargestPoolSize()); + joinPool(p2); + } + + /** + * getMaximumPoolSize returns value given in constructor if not + * otherwise set + */ + public void testGetMaximumPoolSize() { + ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(2, p2.getMaximumPoolSize()); + joinPool(p2); + } + + /** + * getPoolSize increases, but doesn't overestimate, when threads + * become active + */ + public void testGetPoolSize() { + ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(0, p1.getPoolSize()); + p1.execute(new MediumRunnable()); + assertEquals(1, p1.getPoolSize()); + joinPool(p1); + } + + /** + * getTaskCount increases, but doesn't overestimate, when tasks submitted + */ + public void testGetTaskCount() throws InterruptedException { + ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(0, p1.getTaskCount()); + p1.execute(new MediumRunnable()); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, p1.getTaskCount()); + joinPool(p1); + } + + /** + * isShutDown is false before shutdown, true after + */ + public void testIsShutdown() { + + ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertFalse(p1.isShutdown()); + try { p1.shutdown(); } catch (SecurityException ok) { return; } + assertTrue(p1.isShutdown()); + joinPool(p1); + } + + + /** + * isTerminated is false before termination, true after + */ + public void testIsTerminated() throws InterruptedException { + ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertFalse(p1.isTerminated()); + try { + p1.execute(new MediumRunnable()); + } finally { + try { p1.shutdown(); } catch (SecurityException ok) { return; } + } + assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue(p1.isTerminated()); + } + + /** + * isTerminating is not true when running or when terminated + */ + public void testIsTerminating() throws InterruptedException { + ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertFalse(p1.isTerminating()); + try { + p1.execute(new SmallRunnable()); + assertFalse(p1.isTerminating()); + } finally { + try { p1.shutdown(); } catch (SecurityException ok) { return; } + } + assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue(p1.isTerminated()); + assertFalse(p1.isTerminating()); + } + + /** + * getQueue returns the work queue, which contains queued tasks + */ + public void testGetQueue() throws InterruptedException { + BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10); + ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, q); + FutureTask[] tasks = new FutureTask[5]; + for (int i = 0; i < 5; i++) { + tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE); + p1.execute(tasks[i]); + } + try { + Thread.sleep(SHORT_DELAY_MS); + BlockingQueue<Runnable> wq = p1.getQueue(); + assertSame(q, wq); + assertFalse(wq.contains(tasks[0])); + assertTrue(wq.contains(tasks[4])); + for (int i = 1; i < 5; ++i) + tasks[i].cancel(true); + p1.shutdownNow(); + } finally { + joinPool(p1); + } + } + + /** + * remove(task) removes queued task, and fails to remove active task + */ + public void testRemove() throws InterruptedException { + BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10); + ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, q); + FutureTask[] tasks = new FutureTask[5]; + for (int i = 0; i < 5; i++) { + tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE); + p1.execute(tasks[i]); + } + try { + Thread.sleep(SHORT_DELAY_MS); + assertFalse(p1.remove(tasks[0])); + assertTrue(q.contains(tasks[4])); + assertTrue(q.contains(tasks[3])); + assertTrue(p1.remove(tasks[4])); + assertFalse(p1.remove(tasks[4])); + assertFalse(q.contains(tasks[4])); + assertTrue(q.contains(tasks[3])); + assertTrue(p1.remove(tasks[3])); + assertFalse(q.contains(tasks[3])); + } finally { + joinPool(p1); + } + } + + /** + * purge removes cancelled tasks from the queue + */ + public void testPurge() { + ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + FutureTask[] tasks = new FutureTask[5]; + for (int i = 0; i < 5; i++) { + tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE); + p1.execute(tasks[i]); + } + tasks[4].cancel(true); + tasks[3].cancel(true); + p1.purge(); + long count = p1.getTaskCount(); + assertTrue(count >= 2 && count < 5); + joinPool(p1); + } + + /** + * shutDownNow returns a list containing tasks that were not run + */ + public void testShutDownNow() { + ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List l; + try { + for (int i = 0; i < 5; i++) + p1.execute(new MediumPossiblyInterruptedRunnable()); + } + finally { + try { + l = p1.shutdownNow(); + } catch (SecurityException ok) { return; } + } + assertTrue(p1.isShutdown()); + assertTrue(l.size() <= 4); + } + + // Exception Tests + + + /** + * Constructor throws if corePoolSize argument is less than zero + */ + public void testConstructor1() { + try { + new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if maximumPoolSize is less than zero + */ + public void testConstructor2() { + try { + new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if maximumPoolSize is equal to zero + */ + public void testConstructor3() { + try { + new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if keepAliveTime is less than zero + */ + public void testConstructor4() { + try { + new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if corePoolSize is greater than the maximumPoolSize + */ + public void testConstructor5() { + try { + new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if workQueue is set to null + */ + public void testConstructorNullPointerException() { + try { + new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + + /** + * Constructor throws if corePoolSize argument is less than zero + */ + public void testConstructor6() { + try { + new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if maximumPoolSize is less than zero + */ + public void testConstructor7() { + try { + new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if maximumPoolSize is equal to zero + */ + public void testConstructor8() { + try { + new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if keepAliveTime is less than zero + */ + public void testConstructor9() { + try { + new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if corePoolSize is greater than the maximumPoolSize + */ + public void testConstructor10() { + try { + new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if workQueue is set to null + */ + public void testConstructorNullPointerException2() { + try { + new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null,new SimpleThreadFactory()); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Constructor throws if threadFactory is set to null + */ + public void testConstructorNullPointerException3() { + try { + ThreadFactory f = null; + new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + /** + * Constructor throws if corePoolSize argument is less than zero + */ + public void testConstructor11() { + try { + new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if maximumPoolSize is less than zero + */ + public void testConstructor12() { + try { + new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if maximumPoolSize is equal to zero + */ + public void testConstructor13() { + try { + new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if keepAliveTime is less than zero + */ + public void testConstructor14() { + try { + new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if corePoolSize is greater than the maximumPoolSize + */ + public void testConstructor15() { + try { + new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if workQueue is set to null + */ + public void testConstructorNullPointerException4() { + try { + new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null,new NoOpREHandler()); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Constructor throws if handler is set to null + */ + public void testConstructorNullPointerException5() { + try { + RejectedExecutionHandler r = null; + new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + /** + * Constructor throws if corePoolSize argument is less than zero + */ + public void testConstructor16() { + try { + new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if maximumPoolSize is less than zero + */ + public void testConstructor17() { + try { + new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if maximumPoolSize is equal to zero + */ + public void testConstructor18() { + try { + new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if keepAliveTime is less than zero + */ + public void testConstructor19() { + try { + new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if corePoolSize is greater than the maximumPoolSize + */ + public void testConstructor20() { + try { + new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); + shouldThrow(); + } catch (IllegalArgumentException success) {} + } + + /** + * Constructor throws if workQueue is set to null + */ + public void testConstructorNullPointerException6() { + try { + new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler()); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Constructor throws if handler is set to null + */ + public void testConstructorNullPointerException7() { + try { + RejectedExecutionHandler r = null; + new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r); + shouldThrow(); + } catch (NullPointerException success) {} + } + + /** + * Constructor throws if ThreadFactory is set top null + */ + public void testConstructorNullPointerException8() { + try { + ThreadFactory f = null; + new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler()); + shouldThrow(); + } catch (NullPointerException success) {} + } + + + /** + * execute throws RejectedExecutionException + * if saturated. + */ + public void testSaturatedExecute() { + ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1)); + try { + + for (int i = 0; i < 5; ++i) { + p.execute(new MediumRunnable()); + } + shouldThrow(); + } catch (RejectedExecutionException success) {} + joinPool(p); + } + + /** + * executor using CallerRunsPolicy runs task if saturated. + */ + public void testSaturatedExecute2() { + RejectedExecutionHandler h = new CustomTPE.CallerRunsPolicy(); + ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + try { + + TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5]; + for (int i = 0; i < 5; ++i) { + tasks[i] = new TrackedNoOpRunnable(); + } + TrackedLongRunnable mr = new TrackedLongRunnable(); + p.execute(mr); + for (int i = 0; i < 5; ++i) { + p.execute(tasks[i]); + } + for (int i = 1; i < 5; ++i) { + assertTrue(tasks[i].done); + } + try { p.shutdownNow(); } catch (SecurityException ok) { return; } + } finally { + joinPool(p); + } + } + + /** + * executor using DiscardPolicy drops task if saturated. + */ + public void testSaturatedExecute3() { + RejectedExecutionHandler h = new CustomTPE.DiscardPolicy(); + ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + try { + + TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5]; + for (int i = 0; i < 5; ++i) { + tasks[i] = new TrackedNoOpRunnable(); + } + p.execute(new TrackedLongRunnable()); + for (int i = 0; i < 5; ++i) { + p.execute(tasks[i]); + } + for (int i = 0; i < 5; ++i) { + assertFalse(tasks[i].done); + } + try { p.shutdownNow(); } catch (SecurityException ok) { return; } + } finally { + joinPool(p); + } + } + + /** + * executor using DiscardOldestPolicy drops oldest task if saturated. + */ + public void testSaturatedExecute4() { + RejectedExecutionHandler h = new CustomTPE.DiscardOldestPolicy(); + ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + try { + p.execute(new TrackedLongRunnable()); + TrackedLongRunnable r2 = new TrackedLongRunnable(); + p.execute(r2); + assertTrue(p.getQueue().contains(r2)); + TrackedNoOpRunnable r3 = new TrackedNoOpRunnable(); + p.execute(r3); + assertFalse(p.getQueue().contains(r2)); + assertTrue(p.getQueue().contains(r3)); + try { p.shutdownNow(); } catch (SecurityException ok) { return; } + } finally { + joinPool(p); + } + } + + /** + * execute throws RejectedExecutionException if shutdown + */ + public void testRejectedExecutionExceptionOnShutdown() { + ThreadPoolExecutor tpe = + new CustomTPE(1,1,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(1)); + try { tpe.shutdown(); } catch (SecurityException ok) { return; } + try { + tpe.execute(new NoOpRunnable()); + shouldThrow(); + } catch (RejectedExecutionException success) {} + + joinPool(tpe); + } + + /** + * execute using CallerRunsPolicy drops task on shutdown + */ + public void testCallerRunsOnShutdown() { + RejectedExecutionHandler h = new CustomTPE.CallerRunsPolicy(); + ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + + try { p.shutdown(); } catch (SecurityException ok) { return; } + try { + TrackedNoOpRunnable r = new TrackedNoOpRunnable(); + p.execute(r); + assertFalse(r.done); + } finally { + joinPool(p); + } + } + + /** + * execute using DiscardPolicy drops task on shutdown + */ + public void testDiscardOnShutdown() { + RejectedExecutionHandler h = new CustomTPE.DiscardPolicy(); + ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + + try { p.shutdown(); } catch (SecurityException ok) { return; } + try { + TrackedNoOpRunnable r = new TrackedNoOpRunnable(); + p.execute(r); + assertFalse(r.done); + } finally { + joinPool(p); + } + } + + + /** + * execute using DiscardOldestPolicy drops task on shutdown + */ + public void testDiscardOldestOnShutdown() { + RejectedExecutionHandler h = new CustomTPE.DiscardOldestPolicy(); + ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + + try { p.shutdown(); } catch (SecurityException ok) { return; } + try { + TrackedNoOpRunnable r = new TrackedNoOpRunnable(); + p.execute(r); + assertFalse(r.done); + } finally { + joinPool(p); + } + } + + + /** + * execute (null) throws NPE + */ + public void testExecuteNull() { + ThreadPoolExecutor tpe = null; + try { + tpe = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); + tpe.execute(null); + shouldThrow(); + } catch (NullPointerException success) {} + + joinPool(tpe); + } + + /** + * setCorePoolSize of negative value throws IllegalArgumentException + */ + public void testCorePoolSizeIllegalArgumentException() { + ThreadPoolExecutor tpe = + new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); + try { + tpe.setCorePoolSize(-1); + shouldThrow(); + } catch (IllegalArgumentException success) { + } finally { + try { tpe.shutdown(); } catch (SecurityException ok) { return; } + } + joinPool(tpe); + } + + /** + * setMaximumPoolSize(int) throws IllegalArgumentException if + * given a value less the core pool size + */ + public void testMaximumPoolSizeIllegalArgumentException() { + ThreadPoolExecutor tpe = + new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); + try { + tpe.setMaximumPoolSize(1); + shouldThrow(); + } catch (IllegalArgumentException success) { + } finally { + try { tpe.shutdown(); } catch (SecurityException ok) { return; } + } + joinPool(tpe); + } + + /** + * setMaximumPoolSize throws IllegalArgumentException + * if given a negative value + */ + public void testMaximumPoolSizeIllegalArgumentException2() { + ThreadPoolExecutor tpe = + new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); + try { + tpe.setMaximumPoolSize(-1); + shouldThrow(); + } catch (IllegalArgumentException success) { + } finally { + try { tpe.shutdown(); } catch (SecurityException ok) { return; } + } + joinPool(tpe); + } + + + /** + * setKeepAliveTime throws IllegalArgumentException + * when given a negative value + */ + public void testKeepAliveTimeIllegalArgumentException() { + ThreadPoolExecutor tpe = + new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); + + try { + tpe.setKeepAliveTime(-1,MILLISECONDS); + shouldThrow(); + } catch (IllegalArgumentException success) { + } finally { + try { tpe.shutdown(); } catch (SecurityException ok) { return; } + } + joinPool(tpe); + } + + /** + * terminated() is called on termination + */ + public void testTerminated() { + CustomTPE tpe = new CustomTPE(); + try { tpe.shutdown(); } catch (SecurityException ok) { return; } + assertTrue(tpe.terminatedCalled); + joinPool(tpe); + } + + /** + * beforeExecute and afterExecute are called when executing task + */ + public void testBeforeAfter() throws InterruptedException { + CustomTPE tpe = new CustomTPE(); + try { + TrackedNoOpRunnable r = new TrackedNoOpRunnable(); + tpe.execute(r); + Thread.sleep(SHORT_DELAY_MS); + assertTrue(r.done); + assertTrue(tpe.beforeCalled); + assertTrue(tpe.afterCalled); + try { tpe.shutdown(); } catch (SecurityException ok) { return; } + } finally { + joinPool(tpe); + } + } + + /** + * completed submit of callable returns result + */ + public void testSubmitCallable() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + Future<String> future = e.submit(new StringTask()); + String result = future.get(); + assertSame(TEST_STRING, result); + } finally { + joinPool(e); + } + } + + /** + * completed submit of runnable returns successfully + */ + public void testSubmitRunnable() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + Future<?> future = e.submit(new NoOpRunnable()); + future.get(); + assertTrue(future.isDone()); + } finally { + joinPool(e); + } + } + + /** + * completed submit of (runnable, result) returns result + */ + public void testSubmitRunnable2() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING); + String result = future.get(); + assertSame(TEST_STRING, result); + } finally { + joinPool(e); + } + } + + + /** + * invokeAny(null) throws NPE + */ + public void testInvokeAny1() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + e.invokeAny(null); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * invokeAny(empty collection) throws IAE + */ + public void testInvokeAny2() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + e.invokeAny(new ArrayList<Callable<String>>()); + shouldThrow(); + } catch (IllegalArgumentException success) { + } finally { + joinPool(e); + } + } + + /** + * invokeAny(c) throws NPE if c has null elements + */ + public void testInvokeAny3() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(latchAwaitingStringTask(latch)); + l.add(null); + try { + e.invokeAny(l); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + latch.countDown(); + joinPool(e); + } + } + + /** + * invokeAny(c) throws ExecutionException if no task completes + */ + public void testInvokeAny4() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); + try { + e.invokeAny(l); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } finally { + joinPool(e); + } + } + + /** + * invokeAny(c) returns result of some task + */ + public void testInvokeAny5() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(new StringTask()); + String result = e.invokeAny(l); + assertSame(TEST_STRING, result); + } finally { + joinPool(e); + } + } + + /** + * invokeAll(null) throws NPE + */ + public void testInvokeAll1() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + e.invokeAll(null); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * invokeAll(empty collection) returns empty collection + */ + public void testInvokeAll2() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>()); + assertTrue(r.isEmpty()); + } finally { + joinPool(e); + } + } + + /** + * invokeAll(c) throws NPE if c has null elements + */ + public void testInvokeAll3() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(null); + try { + e.invokeAll(l); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * get of element of invokeAll(c) throws exception on failed task + */ + public void testInvokeAll4() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); + List<Future<String>> futures = e.invokeAll(l); + assertEquals(1, futures.size()); + try { + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } finally { + joinPool(e); + } + } + + /** + * invokeAll(c) returns results of all completed tasks + */ + public void testInvokeAll5() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(new StringTask()); + List<Future<String>> futures = e.invokeAll(l); + assertEquals(2, futures.size()); + for (Future<String> future : futures) + assertSame(TEST_STRING, future.get()); + } finally { + joinPool(e); + } + } + + + + /** + * timed invokeAny(null) throws NPE + */ + public void testTimedInvokeAny1() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * timed invokeAny(,,null) throws NPE + */ + public void testTimedInvokeAnyNullTimeUnit() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + try { + e.invokeAny(l, MEDIUM_DELAY_MS, null); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * timed invokeAny(empty collection) throws IAE + */ + public void testTimedInvokeAny2() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (IllegalArgumentException success) { + } finally { + joinPool(e); + } + } + + /** + * timed invokeAny(c) throws NPE if c has null elements + */ + public void testTimedInvokeAny3() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(latchAwaitingStringTask(latch)); + l.add(null); + try { + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + latch.countDown(); + joinPool(e); + } + } + + /** + * timed invokeAny(c) throws ExecutionException if no task completes + */ + public void testTimedInvokeAny4() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); + try { + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } finally { + joinPool(e); + } + } + + /** + * timed invokeAny(c) returns result of some task + */ + public void testTimedInvokeAny5() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(new StringTask()); + String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertSame(TEST_STRING, result); + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(null) throws NPE + */ + public void testTimedInvokeAll1() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(,,null) throws NPE + */ + public void testTimedInvokeAllNullTimeUnit() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + try { + e.invokeAll(l, MEDIUM_DELAY_MS, null); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(empty collection) returns empty collection + */ + public void testTimedInvokeAll2() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); + assertTrue(r.isEmpty()); + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(c) throws NPE if c has null elements + */ + public void testTimedInvokeAll3() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(null); + try { + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) { + } finally { + joinPool(e); + } + } + + /** + * get of element of invokeAll(c) throws exception on failed task + */ + public void testTimedInvokeAll4() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); + List<Future<String>> futures = + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertEquals(1, futures.size()); + try { + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(c) returns results of all completed tasks + */ + public void testTimedInvokeAll5() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(new StringTask()); + List<Future<String>> futures = + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertEquals(2, futures.size()); + for (Future<String> future : futures) + assertSame(TEST_STRING, future.get()); + } finally { + joinPool(e); + } + } + + /** + * timed invokeAll(c) cancels tasks not completed by timeout + */ + public void testTimedInvokeAll6() throws Exception { + ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + try { + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING)); + l.add(new StringTask()); + List<Future<String>> futures = + e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS); + assertEquals(3, futures.size()); + Iterator<Future<String>> it = futures.iterator(); + Future<String> f1 = it.next(); + Future<String> f2 = it.next(); + Future<String> f3 = it.next(); + assertTrue(f1.isDone()); + assertTrue(f2.isDone()); + assertTrue(f3.isDone()); + assertFalse(f1.isCancelled()); + assertTrue(f2.isCancelled()); + } finally { + joinPool(e); + } + } + + /** + * Execution continues if there is at least one thread even if + * thread factory fails to create more + */ + public void testFailingThreadFactory() throws InterruptedException { + ExecutorService e = new CustomTPE(100, 100, LONG_DELAY_MS, MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory()); + try { + for (int k = 0; k < 100; ++k) { + e.execute(new NoOpRunnable()); + } + Thread.sleep(LONG_DELAY_MS); + } finally { + joinPool(e); + } + } + + /** + * allowsCoreThreadTimeOut is by default false. + */ + public void testAllowsCoreThreadTimeOut() { + ThreadPoolExecutor tpe = new CustomTPE(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertFalse(tpe.allowsCoreThreadTimeOut()); + joinPool(tpe); + } + + /** + * allowCoreThreadTimeOut(true) causes idle threads to time out + */ + public void testAllowCoreThreadTimeOut_true() throws InterruptedException { + ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + tpe.allowCoreThreadTimeOut(true); + tpe.execute(new NoOpRunnable()); + try { + Thread.sleep(MEDIUM_DELAY_MS); + assertEquals(0, tpe.getPoolSize()); + } finally { + joinPool(tpe); + } + } + + /** + * allowCoreThreadTimeOut(false) causes idle threads not to time out + */ + public void testAllowCoreThreadTimeOut_false() throws InterruptedException { + ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + tpe.allowCoreThreadTimeOut(false); + tpe.execute(new NoOpRunnable()); + try { + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(tpe.getPoolSize() >= 1); + } finally { + joinPool(tpe); + } + } + +} diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadPoolExecutorTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadPoolExecutorTest.java index ee27e51..9b7fcac 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadPoolExecutorTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadPoolExecutorTest.java @@ -2,13 +2,14 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.util.concurrent.atomic.*; import junit.framework.*; import java.util.*; @@ -17,13 +18,13 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { public static Test suite() { return new TestSuite(ThreadPoolExecutorTest.class); } - + static class ExtendedTPE extends ThreadPoolExecutor { volatile boolean beforeCalled = false; volatile boolean afterCalled = false; volatile boolean terminatedCalled = false; public ExtendedTPE() { - super(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>()); + super(1, 1, LONG_DELAY_MS, MILLISECONDS, new SynchronousQueue<Runnable>()); } protected void beforeExecute(Thread t, Runnable r) { beforeCalled = true; @@ -36,50 +37,37 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { } } - static class FailingThreadFactory implements ThreadFactory{ + static class FailingThreadFactory implements ThreadFactory { int calls = 0; - public Thread newThread(Runnable r){ + public Thread newThread(Runnable r) { if (++calls > 1) return null; return new Thread(r); - } + } } - + /** * execute successfully executes a runnable */ - public void testExecute() { - ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testExecute() throws InterruptedException { + ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { - p1.execute(new Runnable() { - public void run() { - try { - Thread.sleep(SHORT_DELAY_MS); - } catch(InterruptedException e){ - threadUnexpectedException(); - } - } - }); + p1.execute(new ShortRunnable()); Thread.sleep(SMALL_DELAY_MS); - } catch(InterruptedException e){ - unexpectedException(); - } - joinPool(p1); + } finally { + joinPool(p1); + } } /** * getActiveCount increases but doesn't overestimate, when a * thread becomes active */ - public void testGetActiveCount() { - ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testGetActiveCount() throws InterruptedException { + ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); assertEquals(0, p2.getActiveCount()); p2.execute(new MediumRunnable()); - try { - Thread.sleep(SHORT_DELAY_MS); - } catch(Exception e){ - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); assertEquals(1, p2.getActiveCount()); joinPool(p2); } @@ -88,7 +76,7 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { * prestartCoreThread starts a thread if under corePoolSize, else doesn't */ public void testPrestartCoreThread() { - ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); assertEquals(0, p2.getPoolSize()); assertTrue(p2.prestartCoreThread()); assertEquals(1, p2.getPoolSize()); @@ -103,7 +91,7 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { * prestartAllCoreThreads starts all corePoolSize threads */ public void testPrestartAllCoreThreads() { - ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); assertEquals(0, p2.getPoolSize()); p2.prestartAllCoreThreads(); assertEquals(2, p2.getPoolSize()); @@ -111,59 +99,55 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { assertEquals(2, p2.getPoolSize()); joinPool(p2); } - + /** * getCompletedTaskCount increases, but doesn't overestimate, * when tasks complete */ - public void testGetCompletedTaskCount() { - ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testGetCompletedTaskCount() throws InterruptedException { + ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); assertEquals(0, p2.getCompletedTaskCount()); p2.execute(new ShortRunnable()); - try { - Thread.sleep(SMALL_DELAY_MS); - } catch(Exception e){ - unexpectedException(); - } + Thread.sleep(SMALL_DELAY_MS); assertEquals(1, p2.getCompletedTaskCount()); - try { p2.shutdown(); } catch(SecurityException ok) { return; } + try { p2.shutdown(); } catch (SecurityException ok) { return; } joinPool(p2); } - + /** * getCorePoolSize returns size given in constructor if not otherwise set */ public void testGetCorePoolSize() { - ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); assertEquals(1, p1.getCorePoolSize()); joinPool(p1); } - + /** * getKeepAliveTime returns value given in constructor if not otherwise set */ public void testGetKeepAliveTime() { - ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); assertEquals(1, p2.getKeepAliveTime(TimeUnit.SECONDS)); joinPool(p2); } - /** + /** * getThreadFactory returns factory in constructor if not set */ public void testGetThreadFactory() { ThreadFactory tf = new SimpleThreadFactory(); - ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler()); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler()); assertSame(tf, p.getThreadFactory()); joinPool(p); } - /** + /** * setThreadFactory sets the thread factory returned by getThreadFactory */ public void testSetThreadFactory() { - ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); ThreadFactory tf = new SimpleThreadFactory(); p.setThreadFactory(tf); assertSame(tf, p.getThreadFactory()); @@ -171,11 +155,11 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { } - /** + /** * setThreadFactory(null) throws NPE */ public void testSetThreadFactoryNull() { - ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { p.setThreadFactory(null); shouldThrow(); @@ -185,22 +169,22 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { } } - /** + /** * getRejectedExecutionHandler returns handler in constructor if not set */ public void testGetRejectedExecutionHandler() { RejectedExecutionHandler h = new NoOpREHandler(); - ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h); assertSame(h, p.getRejectedExecutionHandler()); joinPool(p); } - /** + /** * setRejectedExecutionHandler sets the handler returned by * getRejectedExecutionHandler */ public void testSetRejectedExecutionHandler() { - ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); RejectedExecutionHandler h = new NoOpREHandler(); p.setRejectedExecutionHandler(h); assertSame(h, p.getRejectedExecutionHandler()); @@ -208,11 +192,11 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { } - /** + /** * setRejectedExecutionHandler(null) throws NPE */ public void testSetRejectedExecutionHandlerNull() { - ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { p.setRejectedExecutionHandler(null); shouldThrow(); @@ -222,124 +206,108 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { } } - + /** * getLargestPoolSize increases, but doesn't overestimate, when * multiple threads active */ - public void testGetLargestPoolSize() { - ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); - try { - assertEquals(0, p2.getLargestPoolSize()); - p2.execute(new MediumRunnable()); - p2.execute(new MediumRunnable()); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(2, p2.getLargestPoolSize()); - } catch(Exception e){ - unexpectedException(); - } + public void testGetLargestPoolSize() throws InterruptedException { + ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(0, p2.getLargestPoolSize()); + p2.execute(new MediumRunnable()); + p2.execute(new MediumRunnable()); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(2, p2.getLargestPoolSize()); joinPool(p2); } - + /** * getMaximumPoolSize returns value given in constructor if not * otherwise set */ public void testGetMaximumPoolSize() { - ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); assertEquals(2, p2.getMaximumPoolSize()); joinPool(p2); } - + /** * getPoolSize increases, but doesn't overestimate, when threads * become active */ public void testGetPoolSize() { - ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); assertEquals(0, p1.getPoolSize()); p1.execute(new MediumRunnable()); assertEquals(1, p1.getPoolSize()); joinPool(p1); } - + /** * getTaskCount increases, but doesn't overestimate, when tasks submitted */ - public void testGetTaskCount() { - ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); - try { - assertEquals(0, p1.getTaskCount()); - p1.execute(new MediumRunnable()); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, p1.getTaskCount()); - } catch(Exception e){ - unexpectedException(); - } + public void testGetTaskCount() throws InterruptedException { + ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertEquals(0, p1.getTaskCount()); + p1.execute(new MediumRunnable()); + Thread.sleep(SHORT_DELAY_MS); + assertEquals(1, p1.getTaskCount()); joinPool(p1); } - + /** * isShutDown is false before shutdown, true after */ public void testIsShutdown() { - - ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + + ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); assertFalse(p1.isShutdown()); - try { p1.shutdown(); } catch(SecurityException ok) { return; } + try { p1.shutdown(); } catch (SecurityException ok) { return; } assertTrue(p1.isShutdown()); joinPool(p1); } - + /** * isTerminated is false before termination, true after */ - public void testIsTerminated() { - ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testIsTerminated() throws InterruptedException { + ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); assertFalse(p1.isTerminated()); try { p1.execute(new MediumRunnable()); } finally { - try { p1.shutdown(); } catch(SecurityException ok) { return; } + try { p1.shutdown(); } catch (SecurityException ok) { return; } } - try { - assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); - assertTrue(p1.isTerminated()); - } catch(Exception e){ - unexpectedException(); - } + assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue(p1.isTerminated()); } /** * isTerminating is not true when running or when terminated */ - public void testIsTerminating() { - ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testIsTerminating() throws InterruptedException { + ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); assertFalse(p1.isTerminating()); try { p1.execute(new SmallRunnable()); assertFalse(p1.isTerminating()); } finally { - try { p1.shutdown(); } catch(SecurityException ok) { return; } + try { p1.shutdown(); } catch (SecurityException ok) { return; } } - try { - assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); - assertTrue(p1.isTerminated()); - assertFalse(p1.isTerminating()); - } catch(Exception e){ - unexpectedException(); - } + assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue(p1.isTerminated()); + assertFalse(p1.isTerminating()); } /** * getQueue returns the work queue, which contains queued tasks */ - public void testGetQueue() { + public void testGetQueue() throws InterruptedException { BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10); - ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q); + ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, q); FutureTask[] tasks = new FutureTask[5]; - for(int i = 0; i < 5; i++){ + for (int i = 0; i < 5; i++) { tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE); p1.execute(tasks[i]); } @@ -352,8 +320,6 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { for (int i = 1; i < 5; ++i) tasks[i].cancel(true); p1.shutdownNow(); - } catch(Exception e) { - unexpectedException(); } finally { joinPool(p1); } @@ -362,11 +328,11 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * remove(task) removes queued task, and fails to remove active task */ - public void testRemove() { + public void testRemove() throws InterruptedException { BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10); - ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q); + ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, q); FutureTask[] tasks = new FutureTask[5]; - for(int i = 0; i < 5; i++){ + for (int i = 0; i < 5; i++) { tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE); p1.execute(tasks[i]); } @@ -381,8 +347,6 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { assertTrue(q.contains(tasks[3])); assertTrue(p1.remove(tasks[3])); assertFalse(q.contains(tasks[3])); - } catch(Exception e) { - unexpectedException(); } finally { joinPool(p1); } @@ -392,9 +356,9 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { * purge removes cancelled tasks from the queue */ public void testPurge() { - ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); FutureTask[] tasks = new FutureTask[5]; - for(int i = 0; i < 5; i++){ + for (int i = 0; i < 5; i++) { tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE); p1.execute(tasks[i]); } @@ -410,355 +374,334 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { * shutDownNow returns a list containing tasks that were not run */ public void testShutDownNow() { - ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); List l; try { - for(int i = 0; i < 5; i++) + for (int i = 0; i < 5; i++) p1.execute(new MediumPossiblyInterruptedRunnable()); } finally { try { l = p1.shutdownNow(); } catch (SecurityException ok) { return; } - } assertTrue(p1.isShutdown()); assertTrue(l.size() <= 4); } // Exception Tests - - /** - * Constructor throws if corePoolSize argument is less than zero + + /** + * Constructor throws if corePoolSize argument is less than zero */ public void testConstructor1() { try { - new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - - /** - * Constructor throws if maximumPoolSize is less than zero + + /** + * Constructor throws if maximumPoolSize is less than zero */ public void testConstructor2() { try { - new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - - /** - * Constructor throws if maximumPoolSize is equal to zero + + /** + * Constructor throws if maximumPoolSize is equal to zero */ public void testConstructor3() { try { - new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + new ThreadPoolExecutor(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if keepAliveTime is less than zero + /** + * Constructor throws if keepAliveTime is less than zero */ public void testConstructor4() { try { - new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + new ThreadPoolExecutor(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if corePoolSize is greater than the maximumPoolSize + /** + * Constructor throws if corePoolSize is greater than the maximumPoolSize */ public void testConstructor5() { try { - new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + new ThreadPoolExecutor(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - - /** - * Constructor throws if workQueue is set to null + + /** + * Constructor throws if workQueue is set to null */ public void testConstructorNullPointerException() { try { - new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null); + new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,null); shouldThrow(); - } - catch (NullPointerException success){} + } catch (NullPointerException success) {} } - - - /** - * Constructor throws if corePoolSize argument is less than zero + + + /** + * Constructor throws if corePoolSize argument is less than zero */ public void testConstructor6() { try { - new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); + new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); shouldThrow(); - } catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - - /** - * Constructor throws if maximumPoolSize is less than zero + + /** + * Constructor throws if maximumPoolSize is less than zero */ public void testConstructor7() { try { - new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); + new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if maximumPoolSize is equal to zero + /** + * Constructor throws if maximumPoolSize is equal to zero */ public void testConstructor8() { try { - new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); + new ThreadPoolExecutor(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if keepAliveTime is less than zero + /** + * Constructor throws if keepAliveTime is less than zero */ public void testConstructor9() { try { - new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); + new ThreadPoolExecutor(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if corePoolSize is greater than the maximumPoolSize + /** + * Constructor throws if corePoolSize is greater than the maximumPoolSize */ public void testConstructor10() { try { - new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); + new ThreadPoolExecutor(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if workQueue is set to null + /** + * Constructor throws if workQueue is set to null */ public void testConstructorNullPointerException2() { try { - new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory()); + new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,null,new SimpleThreadFactory()); shouldThrow(); - } - catch (NullPointerException success){} + } catch (NullPointerException success) {} } - /** - * Constructor throws if threadFactory is set to null + /** + * Constructor throws if threadFactory is set to null */ public void testConstructorNullPointerException3() { try { ThreadFactory f = null; - new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f); + new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f); shouldThrow(); - } - catch (NullPointerException success){} + } catch (NullPointerException success) {} } - - - /** - * Constructor throws if corePoolSize argument is less than zero + + + /** + * Constructor throws if corePoolSize argument is less than zero */ public void testConstructor11() { try { - new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); + new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if maximumPoolSize is less than zero + /** + * Constructor throws if maximumPoolSize is less than zero */ public void testConstructor12() { try { - new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); + new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if maximumPoolSize is equal to zero + /** + * Constructor throws if maximumPoolSize is equal to zero */ public void testConstructor13() { try { - new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); + new ThreadPoolExecutor(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if keepAliveTime is less than zero + /** + * Constructor throws if keepAliveTime is less than zero */ public void testConstructor14() { try { - new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); + new ThreadPoolExecutor(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if corePoolSize is greater than the maximumPoolSize + /** + * Constructor throws if corePoolSize is greater than the maximumPoolSize */ public void testConstructor15() { try { - new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); + new ThreadPoolExecutor(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if workQueue is set to null + /** + * Constructor throws if workQueue is set to null */ public void testConstructorNullPointerException4() { try { - new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new NoOpREHandler()); + new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,null,new NoOpREHandler()); shouldThrow(); - } - catch (NullPointerException success){} + } catch (NullPointerException success) {} } - /** - * Constructor throws if handler is set to null + /** + * Constructor throws if handler is set to null */ public void testConstructorNullPointerException5() { try { RejectedExecutionHandler r = null; - new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r); + new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r); shouldThrow(); - } - catch (NullPointerException success){} + } catch (NullPointerException success) {} } - - /** - * Constructor throws if corePoolSize argument is less than zero + + /** + * Constructor throws if corePoolSize argument is less than zero */ public void testConstructor16() { try { - new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); + new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if maximumPoolSize is less than zero + /** + * Constructor throws if maximumPoolSize is less than zero */ public void testConstructor17() { try { - new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); + new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if maximumPoolSize is equal to zero + /** + * Constructor throws if maximumPoolSize is equal to zero */ public void testConstructor18() { try { - new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); + new ThreadPoolExecutor(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if keepAliveTime is less than zero + /** + * Constructor throws if keepAliveTime is less than zero */ public void testConstructor19() { try { - new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); + new ThreadPoolExecutor(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if corePoolSize is greater than the maximumPoolSize + /** + * Constructor throws if corePoolSize is greater than the maximumPoolSize */ public void testConstructor20() { try { - new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); + new ThreadPoolExecutor(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if workQueue is set to null + /** + * Constructor throws if workQueue is set to null */ public void testConstructorNullPointerException6() { try { - new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler()); + new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler()); shouldThrow(); - } - catch (NullPointerException success){} + } catch (NullPointerException success) {} } - /** - * Constructor throws if handler is set to null + /** + * Constructor throws if handler is set to null */ public void testConstructorNullPointerException7() { try { RejectedExecutionHandler r = null; - new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r); + new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r); shouldThrow(); - } - catch (NullPointerException success){} + } catch (NullPointerException success) {} } - /** - * Constructor throws if ThreadFactory is set top null + /** + * Constructor throws if ThreadFactory is set top null */ public void testConstructorNullPointerException8() { try { ThreadFactory f = null; - new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler()); + new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler()); shouldThrow(); - } - catch (NullPointerException successdn8){} + } catch (NullPointerException success) {} } - + /** * execute throws RejectedExecutionException * if saturated. */ public void testSaturatedExecute() { - ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1)); + ThreadPoolExecutor p = + new ThreadPoolExecutor(1, 1, + LONG_DELAY_MS, MILLISECONDS, + new ArrayBlockingQueue<Runnable>(1)); try { - - for(int i = 0; i < 5; ++i){ + for (int i = 0; i < 2; ++i) p.execute(new MediumRunnable()); + for (int i = 0; i < 2; ++i) { + try { + p.execute(new MediumRunnable()); + shouldThrow(); + } catch (RejectedExecutionException success) {} } - shouldThrow(); - } catch(RejectedExecutionException success){} - joinPool(p); + } finally { + joinPool(p); + } } /** @@ -766,24 +709,22 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { */ public void testSaturatedExecute2() { RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy(); - ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); try { - + TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5]; - for(int i = 0; i < 5; ++i){ + for (int i = 0; i < 5; ++i) { tasks[i] = new TrackedNoOpRunnable(); } TrackedLongRunnable mr = new TrackedLongRunnable(); p.execute(mr); - for(int i = 0; i < 5; ++i){ + for (int i = 0; i < 5; ++i) { p.execute(tasks[i]); } - for(int i = 1; i < 5; ++i) { + for (int i = 1; i < 5; ++i) { assertTrue(tasks[i].done); } - try { p.shutdownNow(); } catch(SecurityException ok) { return; } - } catch(RejectedExecutionException ex){ - unexpectedException(); + try { p.shutdownNow(); } catch (SecurityException ok) { return; } } finally { joinPool(p); } @@ -794,23 +735,21 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { */ public void testSaturatedExecute3() { RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy(); - ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); try { - + TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5]; - for(int i = 0; i < 5; ++i){ + for (int i = 0; i < 5; ++i) { tasks[i] = new TrackedNoOpRunnable(); } p.execute(new TrackedLongRunnable()); - for(int i = 0; i < 5; ++i){ + for (int i = 0; i < 5; ++i) { p.execute(tasks[i]); } - for(int i = 0; i < 5; ++i){ + for (int i = 0; i < 5; ++i) { assertFalse(tasks[i].done); } - try { p.shutdownNow(); } catch(SecurityException ok) { return; } - } catch(RejectedExecutionException ex){ - unexpectedException(); + try { p.shutdownNow(); } catch (SecurityException ok) { return; } } finally { joinPool(p); } @@ -821,7 +760,7 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { */ public void testSaturatedExecute4() { RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy(); - ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); try { p.execute(new TrackedLongRunnable()); TrackedLongRunnable r2 = new TrackedLongRunnable(); @@ -831,9 +770,7 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { p.execute(r3); assertFalse(p.getQueue().contains(r2)); assertTrue(p.getQueue().contains(r3)); - try { p.shutdownNow(); } catch(SecurityException ok) { return; } - } catch(RejectedExecutionException ex){ - unexpectedException(); + try { p.shutdownNow(); } catch (SecurityException ok) { return; } } finally { joinPool(p); } @@ -843,14 +780,14 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { * execute throws RejectedExecutionException if shutdown */ public void testRejectedExecutionExceptionOnShutdown() { - ThreadPoolExecutor tpe = - new ThreadPoolExecutor(1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1)); - try { tpe.shutdown(); } catch(SecurityException ok) { return; } + ThreadPoolExecutor tpe = + new ThreadPoolExecutor(1,1,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(1)); + try { tpe.shutdown(); } catch (SecurityException ok) { return; } try { tpe.execute(new NoOpRunnable()); shouldThrow(); - } catch(RejectedExecutionException success){} - + } catch (RejectedExecutionException success) {} + joinPool(tpe); } @@ -859,15 +796,13 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { */ public void testCallerRunsOnShutdown() { RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy(); - ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); - try { p.shutdown(); } catch(SecurityException ok) { return; } + try { p.shutdown(); } catch (SecurityException ok) { return; } try { TrackedNoOpRunnable r = new TrackedNoOpRunnable(); p.execute(r); assertFalse(r.done); - } catch(RejectedExecutionException success){ - unexpectedException(); } finally { joinPool(p); } @@ -878,15 +813,13 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { */ public void testDiscardOnShutdown() { RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy(); - ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); - try { p.shutdown(); } catch(SecurityException ok) { return; } + try { p.shutdown(); } catch (SecurityException ok) { return; } try { TrackedNoOpRunnable r = new TrackedNoOpRunnable(); p.execute(r); assertFalse(r.done); - } catch(RejectedExecutionException success){ - unexpectedException(); } finally { joinPool(p); } @@ -898,15 +831,13 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { */ public void testDiscardOldestOnShutdown() { RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy(); - ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); + ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); - try { p.shutdown(); } catch(SecurityException ok) { return; } + try { p.shutdown(); } catch (SecurityException ok) { return; } try { TrackedNoOpRunnable r = new TrackedNoOpRunnable(); p.execute(r); assertFalse(r.done); - } catch(RejectedExecutionException success){ - unexpectedException(); } finally { joinPool(p); } @@ -917,89 +848,87 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { * execute (null) throws NPE */ public void testExecuteNull() { - ThreadPoolExecutor tpe = null; + ThreadPoolExecutor tpe = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); try { - tpe = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); tpe.execute(null); shouldThrow(); - } catch(NullPointerException success){} - + } catch (NullPointerException success) {} + joinPool(tpe); } - + /** * setCorePoolSize of negative value throws IllegalArgumentException */ public void testCorePoolSizeIllegalArgumentException() { - ThreadPoolExecutor tpe = null; - try { - tpe = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); - } catch(Exception e){} + ThreadPoolExecutor tpe = + new ThreadPoolExecutor(1, 2, + LONG_DELAY_MS, MILLISECONDS, + new ArrayBlockingQueue<Runnable>(10)); try { tpe.setCorePoolSize(-1); shouldThrow(); - } catch(IllegalArgumentException success){ + } catch (IllegalArgumentException success) { } finally { - try { tpe.shutdown(); } catch(SecurityException ok) { return; } + try { tpe.shutdown(); } catch (SecurityException ok) { return; } } joinPool(tpe); - } + } /** * setMaximumPoolSize(int) throws IllegalArgumentException if * given a value less the core pool size - */ + */ public void testMaximumPoolSizeIllegalArgumentException() { - ThreadPoolExecutor tpe = null; - try { - tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); - } catch(Exception e){} + ThreadPoolExecutor tpe = + new ThreadPoolExecutor(2, 3, + LONG_DELAY_MS, MILLISECONDS, + new ArrayBlockingQueue<Runnable>(10)); try { tpe.setMaximumPoolSize(1); shouldThrow(); - } catch(IllegalArgumentException success){ + } catch (IllegalArgumentException success) { } finally { - try { tpe.shutdown(); } catch(SecurityException ok) { return; } + try { tpe.shutdown(); } catch (SecurityException ok) { return; } } joinPool(tpe); } - + /** * setMaximumPoolSize throws IllegalArgumentException * if given a negative value */ public void testMaximumPoolSizeIllegalArgumentException2() { - ThreadPoolExecutor tpe = null; - try { - tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); - } catch(Exception e){} + ThreadPoolExecutor tpe = + new ThreadPoolExecutor(2, 3, + LONG_DELAY_MS, MILLISECONDS, + new ArrayBlockingQueue<Runnable>(10)); try { tpe.setMaximumPoolSize(-1); shouldThrow(); - } catch(IllegalArgumentException success){ + } catch (IllegalArgumentException success) { } finally { - try { tpe.shutdown(); } catch(SecurityException ok) { return; } + try { tpe.shutdown(); } catch (SecurityException ok) { return; } } joinPool(tpe); } - + /** * setKeepAliveTime throws IllegalArgumentException * when given a negative value */ public void testKeepAliveTimeIllegalArgumentException() { - ThreadPoolExecutor tpe = null; + ThreadPoolExecutor tpe = + new ThreadPoolExecutor(2, 3, + LONG_DELAY_MS, MILLISECONDS, + new ArrayBlockingQueue<Runnable>(10)); try { - tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); - } catch(Exception e){} - - try { - tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS); + tpe.setKeepAliveTime(-1,MILLISECONDS); shouldThrow(); - } catch(IllegalArgumentException success){ + } catch (IllegalArgumentException success) { } finally { - try { tpe.shutdown(); } catch(SecurityException ok) { return; } + try { tpe.shutdown(); } catch (SecurityException ok) { return; } } joinPool(tpe); } @@ -1009,7 +938,7 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { */ public void testTerminated() { ExtendedTPE tpe = new ExtendedTPE(); - try { tpe.shutdown(); } catch(SecurityException ok) { return; } + try { tpe.shutdown(); } catch (SecurityException ok) { return; } assertTrue(tpe.terminatedCalled); joinPool(tpe); } @@ -1017,7 +946,7 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * beforeExecute and afterExecute are called when executing task */ - public void testBeforeAfter() { + public void testBeforeAfter() throws InterruptedException { ExtendedTPE tpe = new ExtendedTPE(); try { TrackedNoOpRunnable r = new TrackedNoOpRunnable(); @@ -1026,10 +955,7 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { assertTrue(r.done); assertTrue(tpe.beforeCalled); assertTrue(tpe.afterCalled); - try { tpe.shutdown(); } catch(SecurityException ok) { return; } - } - catch(Exception ex) { - unexpectedException(); + try { tpe.shutdown(); } catch (SecurityException ok) { return; } } finally { joinPool(tpe); } @@ -1038,18 +964,12 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * completed submit of callable returns result */ - public void testSubmitCallable() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testSubmitCallable() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { Future<String> future = e.submit(new StringTask()); String result = future.get(); assertSame(TEST_STRING, result); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1058,18 +978,12 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * completed submit of runnable returns successfully */ - public void testSubmitRunnable() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testSubmitRunnable() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { Future<?> future = e.submit(new NoOpRunnable()); future.get(); assertTrue(future.isDone()); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1078,37 +992,27 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * completed submit of (runnable, result) returns result */ - public void testSubmitRunnable2() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testSubmitRunnable2() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING); String result = future.get(); assertSame(TEST_STRING, result); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); } finally { joinPool(e); } } - - - /** * invokeAny(null) throws NPE */ - public void testInvokeAny1() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testInvokeAny1() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { e.invokeAny(null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1117,13 +1021,12 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * invokeAny(empty collection) throws IAE */ - public void testInvokeAny2() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testInvokeAny2() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { e.invokeAny(new ArrayList<Callable<String>>()); + shouldThrow(); } catch (IllegalArgumentException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1132,17 +1035,18 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * invokeAny(c) throws NPE if c has null elements */ - public void testInvokeAny3() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testInvokeAny3() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(latchAwaitingStringTask(latch)); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); e.invokeAny(l); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { + latch.countDown(); joinPool(e); } } @@ -1150,15 +1054,15 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * invokeAny(c) throws ExecutionException if no task completes */ - public void testInvokeAny4() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testInvokeAny4() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new NPETask()); e.invokeAny(l); + shouldThrow(); } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -1167,17 +1071,14 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * invokeAny(c) returns result of some task */ - public void testInvokeAny5() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testInvokeAny5() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); String result = e.invokeAny(l); assertSame(TEST_STRING, result); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1186,13 +1087,12 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * invokeAll(null) throws NPE */ - public void testInvokeAll1() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testInvokeAll1() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { e.invokeAll(null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1201,13 +1101,11 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * invokeAll(empty collection) returns empty collection */ - public void testInvokeAll2() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testInvokeAll2() throws InterruptedException { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>()); assertTrue(r.isEmpty()); - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1216,16 +1114,15 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * invokeAll(c) throws NPE if c has null elements */ - public void testInvokeAll3() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testInvokeAll3() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); e.invokeAll(l); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1234,18 +1131,19 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * get of element of invokeAll(c) throws exception on failed task */ - public void testInvokeAll4() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testInvokeAll4() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new NPETask()); - List<Future<String>> result = e.invokeAll(l); - assertEquals(1, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - it.next().get(); - } catch(ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + List<Future<String>> futures = e.invokeAll(l); + assertEquals(1, futures.size()); + try { + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } } finally { joinPool(e); } @@ -1254,19 +1152,16 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * invokeAll(c) returns results of all completed tasks */ - public void testInvokeAll5() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testInvokeAll5() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); - List<Future<String>> result = e.invokeAll(l); - assertEquals(2, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - assertSame(TEST_STRING, it.next().get()); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + List<Future<String>> futures = e.invokeAll(l); + assertEquals(2, futures.size()); + for (Future<String> future : futures) + assertSame(TEST_STRING, future.get()); } finally { joinPool(e); } @@ -1277,13 +1172,12 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAny(null) throws NPE */ - public void testTimedInvokeAny1() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAny1() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { - e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1292,15 +1186,14 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAny(,,null) throws NPE */ - public void testTimedInvokeAnyNullTimeUnit() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAnyNullTimeUnit() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); e.invokeAny(l, MEDIUM_DELAY_MS, null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1309,13 +1202,12 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAny(empty collection) throws IAE */ - public void testTimedInvokeAny2() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAny2() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { - e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (IllegalArgumentException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1324,18 +1216,18 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAny(c) throws NPE if c has null elements */ - public void testTimedInvokeAny3() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAny3() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(latchAwaitingStringTask(latch)); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); - e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { + latch.countDown(); joinPool(e); } } @@ -1343,15 +1235,15 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAny(c) throws ExecutionException if no task completes */ - public void testTimedInvokeAny4() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAny4() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new NPETask()); - e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - } catch(ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -1360,17 +1252,14 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAny(c) returns result of some task */ - public void testTimedInvokeAny5() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAny5() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); - String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); assertSame(TEST_STRING, result); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1379,13 +1268,12 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAll(null) throws NPE */ - public void testTimedInvokeAll1() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAll1() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { - e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1394,15 +1282,14 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAll(,,null) throws NPE */ - public void testTimedInvokeAllNullTimeUnit() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAllNullTimeUnit() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); e.invokeAll(l, MEDIUM_DELAY_MS, null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1411,13 +1298,11 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAll(empty collection) returns empty collection */ - public void testTimedInvokeAll2() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAll2() throws InterruptedException { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { - List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); assertTrue(r.isEmpty()); - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1426,16 +1311,15 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAll(c) throws NPE if c has null elements */ - public void testTimedInvokeAll3() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAll3() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new StringTask()); + l.add(null); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new StringTask()); - l.add(null); - e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1444,18 +1328,18 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * get of element of invokeAll(c) throws exception on failed task */ - public void testTimedInvokeAll4() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAll4() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + List<Callable<String>> l = new ArrayList<Callable<String>>(); + l.add(new NPETask()); + List<Future<String>> futures = + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertEquals(1, futures.size()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); - l.add(new NPETask()); - List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - assertEquals(1, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - it.next().get(); - } catch(ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -1464,19 +1348,17 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAll(c) returns results of all completed tasks */ - public void testTimedInvokeAll5() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAll5() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(new StringTask()); - List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - assertEquals(2, result.size()); - for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) - assertSame(TEST_STRING, it.next().get()); - } catch (ExecutionException success) { - } catch(Exception ex) { - unexpectedException(); + List<Future<String>> futures = + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertEquals(2, futures.size()); + for (Future<String> future : futures) + assertSame(TEST_STRING, future.get()); } finally { joinPool(e); } @@ -1485,16 +1367,17 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { /** * timed invokeAll(c) cancels tasks not completed by timeout */ - public void testTimedInvokeAll6() { - ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + public void testTimedInvokeAll6() throws Exception { + ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); l.add(new StringTask()); l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING)); l.add(new StringTask()); - List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); - assertEquals(3, result.size()); - Iterator<Future<String>> it = result.iterator(); + List<Future<String>> futures = + e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS); + assertEquals(3, futures.size()); + Iterator<Future<String>> it = futures.iterator(); Future<String> f1 = it.next(); Future<String> f2 = it.next(); Future<String> f3 = it.next(); @@ -1503,8 +1386,6 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { assertTrue(f3.isDone()); assertFalse(f1.isCancelled()); assertTrue(f2.isCancelled()); - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -1514,34 +1395,71 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { * Execution continues if there is at least one thread even if * thread factory fails to create more */ - public void testFailingThreadFactory() { - ExecutorService e = new ThreadPoolExecutor(100, 100, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory()); + public void testFailingThreadFactory() throws InterruptedException { + ExecutorService e = new ThreadPoolExecutor(100, 100, LONG_DELAY_MS, MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory()); try { - ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); + List<Callable<String>> l = new ArrayList<Callable<String>>(); for (int k = 0; k < 100; ++k) { e.execute(new NoOpRunnable()); } Thread.sleep(LONG_DELAY_MS); - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } } /** + * allowsCoreThreadTimeOut is by default false. + */ + public void testAllowsCoreThreadTimeOut() { + ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + assertFalse(tpe.allowsCoreThreadTimeOut()); + joinPool(tpe); + } + + /** + * allowCoreThreadTimeOut(true) causes idle threads to time out + */ + public void testAllowCoreThreadTimeOut_true() throws InterruptedException { + ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + tpe.allowCoreThreadTimeOut(true); + tpe.execute(new NoOpRunnable()); + try { + Thread.sleep(MEDIUM_DELAY_MS); + assertEquals(0, tpe.getPoolSize()); + } finally { + joinPool(tpe); + } + } + + /** + * allowCoreThreadTimeOut(false) causes idle threads not to time out + */ + public void testAllowCoreThreadTimeOut_false() throws InterruptedException { + ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); + tpe.allowCoreThreadTimeOut(false); + tpe.execute(new NoOpRunnable()); + try { + Thread.sleep(MEDIUM_DELAY_MS); + assertTrue(tpe.getPoolSize() >= 1); + } finally { + joinPool(tpe); + } + } + + /** * execute allows the same task to be submitted multiple times, even * if rejected */ - public void testRejectedRecycledTask() { + public void testRejectedRecycledTask() throws InterruptedException { final int nTasks = 1000; final AtomicInteger nRun = new AtomicInteger(0); final Runnable recycledTask = new Runnable() { public void run() { nRun.getAndIncrement(); } }; - final ThreadPoolExecutor p = - new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS, + final ThreadPoolExecutor p = + new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS, new ArrayBlockingQueue(30)); try { for (int i = 0; i < nTasks; ++i) { @@ -1556,12 +1474,9 @@ public class ThreadPoolExecutorTest extends JSR166TestCase { } Thread.sleep(5000); // enough time to run all tasks assertEquals(nRun.get(), nTasks); - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { p.shutdown(); } } - + } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadTest.java index 3885c48..e9f28ac 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; @@ -20,7 +20,7 @@ public class ThreadTest extends JSR166TestCase { e.printStackTrace(); } } - + /** * getUncaughtExceptionHandler returns ThreadGroup unless set, * otherwise returning value of last setUncaughtExceptionHandler. @@ -40,7 +40,7 @@ public class ThreadTest extends JSR166TestCase { /** * getDefaultUncaughtExceptionHandler returns value of last - * setDefaultUncaughtExceptionHandler. + * setDefaultUncaughtExceptionHandler. */ public void testGetAndSetDefaultUncaughtExceptionHandler() { assertEquals(null, Thread.getDefaultUncaughtExceptionHandler()); @@ -54,12 +54,12 @@ public class ThreadTest extends JSR166TestCase { assertEquals(eh, Thread.getDefaultUncaughtExceptionHandler()); Thread.setDefaultUncaughtExceptionHandler(null); } - catch(SecurityException ok) { + catch (SecurityException ok) { } assertEquals(null, Thread.getDefaultUncaughtExceptionHandler()); } - + // How to test actually using UEH within junit? } diff --git a/concurrent/src/test/java/tests/api/java/util/concurrent/TimeUnitTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/TimeUnitTest.java index f6504d8..84be0c4 100755 --- a/concurrent/src/test/java/tests/api/java/util/concurrent/TimeUnitTest.java +++ b/concurrent/src/test/java/tests/api/java/util/concurrent/TimeUnitTest.java @@ -2,11 +2,11 @@ * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ -package tests.api.java.util.concurrent; +package tests.api.java.util.concurrent; // android-added import junit.framework.*; import java.util.concurrent.*; @@ -24,57 +24,93 @@ public class TimeUnitTest extends JSR166TestCase { */ public void testConvert() { for (long t = 0; t < 88888; ++t) { + assertEquals(t*60*60*24, + TimeUnit.SECONDS.convert(t, + TimeUnit.DAYS)); + assertEquals(t*60*60, + TimeUnit.SECONDS.convert(t, + TimeUnit.HOURS)); + assertEquals(t*60, + TimeUnit.SECONDS.convert(t, + TimeUnit.MINUTES)); assertEquals(t, - TimeUnit.SECONDS.convert(t, + TimeUnit.SECONDS.convert(t, TimeUnit.SECONDS)); - assertEquals(t, - TimeUnit.SECONDS.convert(1000L*t, + assertEquals(t, + TimeUnit.SECONDS.convert(1000L*t, TimeUnit.MILLISECONDS)); - assertEquals(t, - TimeUnit.SECONDS.convert(1000000L*t, + assertEquals(t, + TimeUnit.SECONDS.convert(1000000L*t, TimeUnit.MICROSECONDS)); - assertEquals(t, - TimeUnit.SECONDS.convert(1000000000L*t, + assertEquals(t, + TimeUnit.SECONDS.convert(1000000000L*t, TimeUnit.NANOSECONDS)); + assertEquals(1000L*t*60*60*24, + TimeUnit.MILLISECONDS.convert(t, + TimeUnit.DAYS)); + assertEquals(1000L*t*60*60, + TimeUnit.MILLISECONDS.convert(t, + TimeUnit.HOURS)); + assertEquals(1000L*t*60, + TimeUnit.MILLISECONDS.convert(t, + TimeUnit.MINUTES)); assertEquals(1000L*t, - TimeUnit.MILLISECONDS.convert(t, + TimeUnit.MILLISECONDS.convert(t, TimeUnit.SECONDS)); - assertEquals(t, - TimeUnit.MILLISECONDS.convert(t, + assertEquals(t, + TimeUnit.MILLISECONDS.convert(t, TimeUnit.MILLISECONDS)); - assertEquals(t, - TimeUnit.MILLISECONDS.convert(1000L*t, + assertEquals(t, + TimeUnit.MILLISECONDS.convert(1000L*t, TimeUnit.MICROSECONDS)); - assertEquals(t, - TimeUnit.MILLISECONDS.convert(1000000L*t, + assertEquals(t, + TimeUnit.MILLISECONDS.convert(1000000L*t, TimeUnit.NANOSECONDS)); + assertEquals(1000000L*t*60*60*24, + TimeUnit.MICROSECONDS.convert(t, + TimeUnit.DAYS)); + assertEquals(1000000L*t*60*60, + TimeUnit.MICROSECONDS.convert(t, + TimeUnit.HOURS)); + assertEquals(1000000L*t*60, + TimeUnit.MICROSECONDS.convert(t, + TimeUnit.MINUTES)); assertEquals(1000000L*t, - TimeUnit.MICROSECONDS.convert(t, + TimeUnit.MICROSECONDS.convert(t, TimeUnit.SECONDS)); - assertEquals(1000L*t, - TimeUnit.MICROSECONDS.convert(t, + assertEquals(1000L*t, + TimeUnit.MICROSECONDS.convert(t, TimeUnit.MILLISECONDS)); - assertEquals(t, - TimeUnit.MICROSECONDS.convert(t, + assertEquals(t, + TimeUnit.MICROSECONDS.convert(t, TimeUnit.MICROSECONDS)); - assertEquals(t, - TimeUnit.MICROSECONDS.convert(1000L*t, + assertEquals(t, + TimeUnit.MICROSECONDS.convert(1000L*t, TimeUnit.NANOSECONDS)); + assertEquals(1000000000L*t*60*60*24, + TimeUnit.NANOSECONDS.convert(t, + TimeUnit.DAYS)); + assertEquals(1000000000L*t*60*60, + TimeUnit.NANOSECONDS.convert(t, + TimeUnit.HOURS)); + assertEquals(1000000000L*t*60, + TimeUnit.NANOSECONDS.convert(t, + TimeUnit.MINUTES)); assertEquals(1000000000L*t, - TimeUnit.NANOSECONDS.convert(t, + TimeUnit.NANOSECONDS.convert(t, TimeUnit.SECONDS)); - assertEquals(1000000L*t, - TimeUnit.NANOSECONDS.convert(t, + assertEquals(1000000L*t, + TimeUnit.NANOSECONDS.convert(t, TimeUnit.MILLISECONDS)); - assertEquals(1000L*t, - TimeUnit.NANOSECONDS.convert(t, + assertEquals(1000L*t, + TimeUnit.NANOSECONDS.convert(t, TimeUnit.MICROSECONDS)); - assertEquals(t, - TimeUnit.NANOSECONDS.convert(t, + assertEquals(t, + TimeUnit.NANOSECONDS.convert(t, TimeUnit.NANOSECONDS)); } } @@ -85,13 +121,19 @@ public class TimeUnitTest extends JSR166TestCase { */ public void testToNanos() { for (long t = 0; t < 88888; ++t) { + assertEquals(t*1000000000L*60*60*24, + TimeUnit.DAYS.toNanos(t)); + assertEquals(t*1000000000L*60*60, + TimeUnit.HOURS.toNanos(t)); + assertEquals(t*1000000000L*60, + TimeUnit.MINUTES.toNanos(t)); assertEquals(1000000000L*t, TimeUnit.SECONDS.toNanos(t)); - assertEquals(1000000L*t, + assertEquals(1000000L*t, TimeUnit.MILLISECONDS.toNanos(t)); - assertEquals(1000L*t, + assertEquals(1000L*t, TimeUnit.MICROSECONDS.toNanos(t)); - assertEquals(t, + assertEquals(t, TimeUnit.NANOSECONDS.toNanos(t)); } } @@ -102,13 +144,19 @@ public class TimeUnitTest extends JSR166TestCase { */ public void testToMicros() { for (long t = 0; t < 88888; ++t) { + assertEquals(t*1000000L*60*60*24, + TimeUnit.DAYS.toMicros(t)); + assertEquals(t*1000000L*60*60, + TimeUnit.HOURS.toMicros(t)); + assertEquals(t*1000000L*60, + TimeUnit.MINUTES.toMicros(t)); assertEquals(1000000L*t, TimeUnit.SECONDS.toMicros(t)); - assertEquals(1000L*t, + assertEquals(1000L*t, TimeUnit.MILLISECONDS.toMicros(t)); - assertEquals(t, + assertEquals(t, TimeUnit.MICROSECONDS.toMicros(t)); - assertEquals(t, + assertEquals(t, TimeUnit.NANOSECONDS.toMicros(t*1000L)); } } @@ -119,13 +167,19 @@ public class TimeUnitTest extends JSR166TestCase { */ public void testToMillis() { for (long t = 0; t < 88888; ++t) { + assertEquals(t*1000L*60*60*24, + TimeUnit.DAYS.toMillis(t)); + assertEquals(t*1000L*60*60, + TimeUnit.HOURS.toMillis(t)); + assertEquals(t*1000L*60, + TimeUnit.MINUTES.toMillis(t)); assertEquals(1000L*t, TimeUnit.SECONDS.toMillis(t)); - assertEquals(t, + assertEquals(t, TimeUnit.MILLISECONDS.toMillis(t)); - assertEquals(t, + assertEquals(t, TimeUnit.MICROSECONDS.toMillis(t*1000L)); - assertEquals(t, + assertEquals(t, TimeUnit.NANOSECONDS.toMillis(t*1000000L)); } } @@ -136,19 +190,95 @@ public class TimeUnitTest extends JSR166TestCase { */ public void testToSeconds() { for (long t = 0; t < 88888; ++t) { + assertEquals(t*60*60*24, + TimeUnit.DAYS.toSeconds(t)); + assertEquals(t*60*60, + TimeUnit.HOURS.toSeconds(t)); + assertEquals(t*60, + TimeUnit.MINUTES.toSeconds(t)); assertEquals(t, TimeUnit.SECONDS.toSeconds(t)); - assertEquals(t, + assertEquals(t, TimeUnit.MILLISECONDS.toSeconds(t*1000L)); - assertEquals(t, + assertEquals(t, TimeUnit.MICROSECONDS.toSeconds(t*1000000L)); - assertEquals(t, + assertEquals(t, TimeUnit.NANOSECONDS.toSeconds(t*1000000000L)); } } /** - * convert saturates positive too-large values to Long.MAX_VALUE + * toMinutes correctly converts sample values in different units to + * minutes + */ + public void testToMinutes() { + for (long t = 0; t < 88888; ++t) { + assertEquals(t*60*24, + TimeUnit.DAYS.toMinutes(t)); + assertEquals(t*60, + TimeUnit.HOURS.toMinutes(t)); + assertEquals(t, + TimeUnit.MINUTES.toMinutes(t)); + assertEquals(t, + TimeUnit.SECONDS.toMinutes(t*60)); + assertEquals(t, + TimeUnit.MILLISECONDS.toMinutes(t*1000L*60)); + assertEquals(t, + TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60)); + assertEquals(t, + TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60)); + } + } + + /** + * toHours correctly converts sample values in different units to + * hours + */ + public void testToHours() { + for (long t = 0; t < 88888; ++t) { + assertEquals(t*24, + TimeUnit.DAYS.toHours(t)); + assertEquals(t, + TimeUnit.HOURS.toHours(t)); + assertEquals(t, + TimeUnit.MINUTES.toHours(t*60)); + assertEquals(t, + TimeUnit.SECONDS.toHours(t*60*60)); + assertEquals(t, + TimeUnit.MILLISECONDS.toHours(t*1000L*60*60)); + assertEquals(t, + TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60)); + assertEquals(t, + TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60)); + } + } + + /** + * toDays correctly converts sample values in different units to + * days + */ + public void testToDays() { + for (long t = 0; t < 88888; ++t) { + assertEquals(t, + TimeUnit.DAYS.toDays(t)); + assertEquals(t, + TimeUnit.HOURS.toDays(t*24)); + assertEquals(t, + TimeUnit.MINUTES.toDays(t*60*24)); + assertEquals(t, + TimeUnit.SECONDS.toDays(t*60*60*24)); + assertEquals(t, + TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24)); + assertEquals(t, + TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24)); + assertEquals(t, + TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24)); + } + } + + + /** + * convert saturates positive too-large values to Long.MAX_VALUE * and negative to LONG.MIN_VALUE */ public void testConvertSaturate() { @@ -158,18 +288,35 @@ public class TimeUnitTest extends JSR166TestCase { assertEquals(Long.MIN_VALUE, TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4, TimeUnit.SECONDS)); - + assertEquals(Long.MAX_VALUE, + TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2, + TimeUnit.MINUTES)); + assertEquals(Long.MIN_VALUE, + TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4, + TimeUnit.MINUTES)); + assertEquals(Long.MAX_VALUE, + TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2, + TimeUnit.HOURS)); + assertEquals(Long.MIN_VALUE, + TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4, + TimeUnit.HOURS)); + assertEquals(Long.MAX_VALUE, + TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2, + TimeUnit.DAYS)); + assertEquals(Long.MIN_VALUE, + TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4, + TimeUnit.DAYS)); } /** - * toNanos saturates positive too-large values to Long.MAX_VALUE + * toNanos saturates positive too-large values to Long.MAX_VALUE * and negative to LONG.MIN_VALUE */ public void testToNanosSaturate() { - assertEquals(Long.MAX_VALUE, - TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2)); - assertEquals(Long.MIN_VALUE, - TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3)); + assertEquals(Long.MAX_VALUE, + TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2)); + assertEquals(Long.MIN_VALUE, + TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3)); } @@ -181,151 +328,100 @@ public class TimeUnitTest extends JSR166TestCase { assertTrue(s.indexOf("ECOND") >= 0); } - + /** * Timed wait without holding lock throws * IllegalMonitorStateException */ - public void testTimedWait_IllegalMonitorException() { - //created a new thread with anonymous runnable - - Thread t = new Thread(new Runnable() { - public void run() { - Object o = new Object(); - TimeUnit tu = TimeUnit.MILLISECONDS; - try { - tu.timedWait(o,LONG_DELAY_MS); - threadShouldThrow(); - } - catch (InterruptedException ie) { - threadUnexpectedException(); - } - catch(IllegalMonitorStateException success) { - } - - } - }); + public void testTimedWait_IllegalMonitorException() throws Exception { + Thread t = new Thread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Object o = new Object(); + TimeUnit tu = TimeUnit.MILLISECONDS; + try { + tu.timedWait(o,LONG_DELAY_MS); + threadShouldThrow(); + } catch (IllegalMonitorStateException success) {}}}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(Exception e) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } - + /** * timedWait throws InterruptedException when interrupted */ - public void testTimedWait() { - Thread t = new Thread(new Runnable() { - public void run() { - Object o = new Object(); - - TimeUnit tu = TimeUnit.MILLISECONDS; - try { - synchronized(o) { - tu.timedWait(o,MEDIUM_DELAY_MS); - } - threadShouldThrow(); - } - catch(InterruptedException success) {} - catch(IllegalMonitorStateException failure) { - threadUnexpectedException(); - } + public void testTimedWait() throws InterruptedException { + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + Object o = new Object(); + + TimeUnit tu = TimeUnit.MILLISECONDS; + synchronized(o) { + tu.timedWait(o,MEDIUM_DELAY_MS); } - }); + }}); t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(Exception e) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } - - + + /** * timedJoin throws InterruptedException when interrupted */ - public void testTimedJoin() { - Thread t = new Thread(new Runnable() { - public void run() { - TimeUnit tu = TimeUnit.MILLISECONDS; - try { - Thread s = new Thread(new Runnable() { - public void run() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - } catch(InterruptedException success){} - } - }); - s.start(); - tu.timedJoin(s,MEDIUM_DELAY_MS); - threadShouldThrow(); - } - catch(Exception e) {} - } - }); + public void testTimedJoin() throws InterruptedException { + final Thread s = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(MEDIUM_DELAY_MS); + }}); + final Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + TimeUnit tu = TimeUnit.MILLISECONDS; + tu.timedJoin(s, MEDIUM_DELAY_MS); + }});; + s.start(); t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(Exception e) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); + s.interrupt(); + s.join(); } - + /** * timedSleep throws InterruptedException when interrupted */ - public void testTimedSleep() { - //created a new thread with anonymous runnable - - Thread t = new Thread(new Runnable() { - public void run() { - TimeUnit tu = TimeUnit.MILLISECONDS; - try { - tu.sleep(MEDIUM_DELAY_MS); - threadShouldThrow(); - } - catch(InterruptedException success) {} - } - }); + public void testTimedSleep() throws InterruptedException { + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + TimeUnit tu = TimeUnit.MILLISECONDS; + tu.sleep(MEDIUM_DELAY_MS); + }}); + t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(Exception e) { - unexpectedException(); - } + Thread.sleep(SHORT_DELAY_MS); + t.interrupt(); + t.join(); } /** - * a deserialized serialized unit is equal + * a deserialized serialized unit is the same instance */ - public void testSerialization() { + public void testSerialization() throws Exception { TimeUnit q = TimeUnit.MILLISECONDS; - try { - ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); - ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); - out.writeObject(q); - out.close(); - - ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); - ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); - TimeUnit r = (TimeUnit)in.readObject(); - - assertEquals(q.toString(), r.toString()); - } catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + ByteArrayOutputStream bout = new ByteArrayOutputStream(10000); + ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout)); + out.writeObject(q); + out.close(); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); + ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); + TimeUnit r = (TimeUnit)in.readObject(); + assertSame(q, r); } } |