merge more modules into luni

54 files changed, 0 insertions, 31747 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
deleted file mode 100644
index a8db7ad..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractExecutorServiceTest.java
+++ /dev/null
@@ -1,666 +0,0 @@
-/*
- * 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.math.BigInteger;
-import java.security.*;
-
-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.
-     */
-    static class DirectExecutorService extends AbstractExecutorService {
-        public void execute(Runnable r) { r.run(); }
-        public void shutdown() { shutdown = true; }
-        public List<Runnable> shutdownNow() { shutdown = true; return Collections.EMPTY_LIST; }
-        public boolean isShutdown() { return shutdown; }
-        public boolean isTerminated() { return isShutdown(); }
-        public boolean awaitTermination(long timeout, TimeUnit unit) { return isShutdown(); }
-        private volatile boolean shutdown = false;
-    }
-
-    /**
-     * execute(runnable) runs it to completion
-     */
-    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() 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() 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() 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 runs to completion
-     */
-    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;
-                    }}));
-
-                assertSame(TEST_STRING, future.get());
-            }};
-
-        runWithPermissions(r,
-                           new RuntimePermission("getClassLoader"),
-                           new RuntimePermission("setContextClassLoader"),
-                           new RuntimePermission("modifyThread"));
-    }
-
-    /**
-     * A submitted privileged exception action runs to completion
-     */
-    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;
-                    }}));
-
-                assertSame(TEST_STRING, future.get());
-            }};
-
-        runWithPermissions(r);
-    }
-
-    /**
-     * A submitted failed privileged exception action reports exception
-     */
-    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();
-                    }}));
-
-                try {
-                    future.get();
-                    shouldThrow();
-                } catch (ExecutionException success) {
-                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
-                }}};
-
-        runWithPermissions(r);
-    }
-
-    /**
-     * execute(null runnable) throws NPE
-     */
-    public void testExecuteNullRunnable() {
-        try {
-            ExecutorService e = new DirectExecutorService();
-            e.submit((Runnable) null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * submit(null callable) throws NPE
-     */
-    public void testSubmitNullCallable() {
-        try {
-            ExecutorService e = new DirectExecutorService();
-            e.submit((Callable) null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * submit(runnable) throws RejectedExecutionException if
-     * executor is saturated.
-     */
-    public void testExecute1() {
-        ThreadPoolExecutor p =
-            new ThreadPoolExecutor(1, 1,
-                                   60, TimeUnit.SECONDS,
-                                   new ArrayBlockingQueue<Runnable>(1));
-        try {
-            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) {}
-            }
-        } finally {
-            joinPool(p);
-        }
-    }
-
-    /**
-     * submit(callable) throws RejectedExecutionException
-     * if executor is saturated.
-     */
-    public void testExecute2() {
-        ThreadPoolExecutor p =
-            new ThreadPoolExecutor(1, 1,
-                                   60, TimeUnit.SECONDS,
-                                   new ArrayBlockingQueue<Runnable>(1));
-        try {
-            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) {}
-            }
-        } finally {
-            joinPool(p);
-        }
-    }
-
-
-    /**
-     *  Blocking on submit(callable) throws InterruptedException if
-     *  caller interrupted.
-     */
-    public void testInterruptedSubmit() 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 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 InterruptedException if callable
-     *  interrupted
-     */
-    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);
-    }
-
-    /**
-     *  get of submit(callable) throws ExecutionException if callable
-     *  throws exception
-     */
-    public void testSubmitEE() throws InterruptedException {
-        ThreadPoolExecutor p =
-            new ThreadPoolExecutor(1, 1,
-                                   60, TimeUnit.SECONDS,
-                                   new ArrayBlockingQueue<Runnable>(10));
-
-        Callable c = new Callable() {
-            public Object call() { return 5/0; }};
-
-        try {
-            p.submit(c).get();
-            shouldThrow();
-        } catch (ExecutionException success) {
-            assertTrue(success.getCause() instanceof ArithmeticException);
-        }
-        joinPool(p);
-    }
-
-    /**
-     * invokeAny(null) throws NPE
-     */
-    public void testInvokeAny1()
-        throws InterruptedException, ExecutionException {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            e.invokeAny(null);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * invokeAny(empty collection) throws IAE
-     */
-    public void testInvokeAny2()
-        throws InterruptedException, ExecutionException {
-        ExecutorService e = new DirectExecutorService();
-        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 {
-        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 {
-            e.invokeAny(l);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * invokeAny(c) throws ExecutionException if no task in c completes
-     */
-    public void testInvokeAny4() throws InterruptedException {
-        ExecutorService e = new DirectExecutorService();
-        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 in c if at least one completes
-     */
-    public void testInvokeAny5() throws Exception {
-        ExecutorService e = new DirectExecutorService();
-        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 InterruptedException {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            e.invokeAll(null);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * invokeAll(empty collection) returns empty collection
-     */
-    public void testInvokeAll2() throws InterruptedException {
-        ExecutorService e = new DirectExecutorService();
-        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 InterruptedException {
-        ExecutorService e = new DirectExecutorService();
-        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 returned element of invokeAll(c) throws exception on failed task
-     */
-    public void testInvokeAll4() throws Exception {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            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 in c
-     */
-    public void testInvokeAll5() throws Exception {
-        ExecutorService e = new DirectExecutorService();
-        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 DirectExecutorService();
-        try {
-            e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * timed invokeAny(null time unit) throws NPE
-     */
-    public void testTimedInvokeAnyNullTimeUnit() throws Exception {
-        ExecutorService e = new DirectExecutorService();
-        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 DirectExecutorService();
-        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 {
-        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 {
-            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * timed invokeAny(c) throws ExecutionException if no task completes
-     */
-    public void testTimedInvokeAny4() throws Exception {
-        ExecutorService e = new DirectExecutorService();
-        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 in c
-     */
-    public void testTimedInvokeAny5() throws Exception {
-        ExecutorService e = new DirectExecutorService();
-        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 InterruptedException {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * timed invokeAll(null time unit) throws NPE
-     */
-    public void testTimedInvokeAllNullTimeUnit() throws InterruptedException {
-        ExecutorService e = new DirectExecutorService();
-        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 InterruptedException {
-        ExecutorService e = new DirectExecutorService();
-        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 InterruptedException {
-        ExecutorService e = new DirectExecutorService();
-        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 returned element of invokeAll(c) throws exception on failed task
-     */
-    public void testTimedInvokeAll4() throws Exception {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            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 in c
-     */
-    public void testTimedInvokeAll5() throws Exception {
-        ExecutorService e = new DirectExecutorService();
-        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 cancels tasks not completed by timeout
-     */
-    public void testTimedInvokeAll6() throws InterruptedException {
-        ExecutorService e = new DirectExecutorService();
-        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, 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();
-            assertTrue(f1.isDone());
-            assertFalse(f1.isCancelled());
-            assertTrue(f2.isDone());
-            assertTrue(f3.isDone());
-            assertTrue(f3.isCancelled());
-        } 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
deleted file mode 100644
index 9bb206b..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueueTest.java
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * 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 java.util.concurrent.locks.*;
-import java.io.*;
-
-public class AbstractQueueTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(AbstractQueueTest.class);
-    }
-
-    static class Succeed extends AbstractQueue<Integer> {
-        public boolean offer(Integer x) {
-            if (x == null) throw new NullPointerException();
-            return true;
-        }
-        public Integer peek() { return one; }
-        public Integer poll() { return one; }
-        public int size() { return 0; }
-        public Iterator iterator() { return null; } // not needed
-    }
-
-    static class Fail extends AbstractQueue<Integer> {
-        public boolean offer(Integer x) {
-            if (x == null) throw new NullPointerException();
-            return false;
-        }
-        public Integer peek() { return null; }
-        public Integer poll() { return null; }
-        public int size() { return 0; }
-        public Iterator iterator() { return null; } // not needed
-    }
-
-    /**
-     * add returns true if offer succeeds
-     */
-    public void testAddS() {
-        Succeed q = new Succeed();
-        assertTrue(q.add(two));
-    }
-
-    /**
-     * add throws ISE true if offer fails
-     */
-    public void testAddF() {
-        Fail q = new Fail();
-        try {
-            q.add(one);
-            shouldThrow();
-        } catch (IllegalStateException success) {}
-    }
-
-    /**
-     * add throws NPE if offer does
-     */
-    public void testAddNPE() {
-        Succeed q = new Succeed();
-        try {
-            q.add(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * remove returns normally if poll succeeds
-     */
-    public void testRemoveS() {
-        Succeed q = new Succeed();
-        q.remove();
-    }
-
-    /**
-     * remove throws NSEE if poll returns null
-     */
-    public void testRemoveF() {
-        Fail q = new Fail();
-        try {
-            q.remove();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-
-    /**
-     * element returns normally if peek succeeds
-     */
-    public void testElementS() {
-        Succeed q = new Succeed();
-        q.element();
-    }
-
-    /**
-     * element throws NSEE if peek returns null
-     */
-    public void testElementF() {
-        Fail q = new Fail();
-        try {
-            q.element();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     *  addAll(null) throws NPE
-     */
-    public void testAddAll1() {
-        try {
-            Succeed q = new Succeed();
-            q.addAll(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * addAll(this) throws IAE
-     */
-    public void testAddAllSelf() {
-        try {
-            Succeed q = new Succeed();
-            q.addAll(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-
-    /**
-     *  addAll of a collection with null elements throws NPE
-     */
-    public void testAddAll2() {
-        try {
-            Succeed q = new Succeed();
-            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 {
-            Succeed q = new Succeed();
-            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 an add fails
-     */
-    public void testAddAll4() {
-        try {
-            Fail q = new Fail();
-            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) {}
-    }
-
-}
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
deleted file mode 100644
index 43a4bd1..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueuedLongSynchronizerTest.java
+++ /dev/null
@@ -1,1025 +0,0 @@
-/*
- * 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
deleted file mode 100644
index a5b6554..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AbstractQueuedSynchronizerTest.java
+++ /dev/null
@@ -1,1023 +0,0 @@
-/*
- * 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;
-
-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 AbstractQueuedSynchronizerTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(AbstractQueuedSynchronizerTest.class);
-    }
-
-    /**
-     * A simple mutex class, adapted from the
-     * AbstractQueuedSynchronizer javadoc.  Exclusive acquire tests
-     * exercise this as a sample user extension.  Other
-     * methods/features of AbstractQueuedSynchronizerTest are tested
-     * via other test classes, including those for ReentrantLock,
-     * ReentrantReadWriteLock, and Semaphore
-     */
-    static class Mutex extends AbstractQueuedSynchronizer {
-        public boolean isHeldExclusively() { return getState() == 1; }
-
-        public boolean tryAcquire(int acquires) {
-            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 {
-        public boolean isSignalled() { return getState() != 0; }
-
-        public int tryAcquireShared(int ignore) {
-            return isSignalled()? 1 : -1;
-        }
-
-        public boolean tryReleaseShared(int ignore) {
-            setState(1);
-            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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
-        try {
-            c.await();
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-    /**
-     * Calling signal without holding sync throws IllegalMonitorStateException
-     */
-    public void testSignal_IllegalMonitor() {
-        final Mutex sync = new Mutex();
-        final AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 AbstractQueuedSynchronizer.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 = 1") >= 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/ArrayBlockingQueueTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ArrayBlockingQueueTest.java
deleted file mode 100755
index 8fc5cb6..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ArrayBlockingQueueTest.java
+++ /dev/null
@@ -1,920 +0,0 @@
-/*
- * 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.io.*;
-
-public class ArrayBlockingQueueTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(ArrayBlockingQueueTest.class);
-    }
-
-    /**
-     * Create a queue of given size containing consecutive
-     * Integers 0 ... n.
-     */
-    private ArrayBlockingQueue populatedQueue(int n) {
-        ArrayBlockingQueue q = new ArrayBlockingQueue(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;
-    }
-
-    /**
-     * A new queue has the indicated capacity
-     */
-    public void testConstructor1() {
-        assertEquals(SIZE, new ArrayBlockingQueue(SIZE).remainingCapacity());
-    }
-
-    /**
-     * Constructor throws IAE if capacity argument nonpositive
-     */
-    public void testConstructor2() {
-        try {
-            ArrayBlockingQueue q = new ArrayBlockingQueue(0);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * Initializing from null Collection throws NPE
-     */
-    public void testConstructor3() {
-        try {
-            ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Initializing from Collection of null elements throws NPE
-     */
-    public void testConstructor4() {
-        try {
-            Integer[] ints = new Integer[SIZE];
-            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, 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);
-            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Initializing from too large collection throws IAE
-     */
-    public void testConstructor6() {
-        try {
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
-                ints[i] = new Integer(i);
-            ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * Queue contains all elements of collection used to initialize
-     */
-    public void testConstructor7() {
-        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());
-    }
-
-    /**
-     * Queue transitions from empty to full when elements added
-     */
-    public void testEmptyFull() {
-        ArrayBlockingQueue q = new ArrayBlockingQueue(2);
-        assertTrue(q.isEmpty());
-        assertEquals(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() {
-        ArrayBlockingQueue q = populatedQueue(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 {
-            ArrayBlockingQueue q = new ArrayBlockingQueue(1);
-            q.offer(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     *  add(null) throws NPE
-     */
-    public void testAddNull() {
-        try {
-            ArrayBlockingQueue q = new ArrayBlockingQueue(1);
-            q.add(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Offer succeeds if not full; fails if full
-     */
-    public void testOffer() {
-        ArrayBlockingQueue q = new ArrayBlockingQueue(1);
-        assertTrue(q.offer(zero));
-        assertFalse(q.offer(one));
-    }
-
-    /**
-     * add succeeds if not full; throws ISE if full
-     */
-    public void testAdd() {
-        try {
-            ArrayBlockingQueue q = new ArrayBlockingQueue(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 {
-            ArrayBlockingQueue q = new ArrayBlockingQueue(1);
-            q.addAll(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * addAll(this) throws IAE
-     */
-    public void testAddAllSelf() {
-        try {
-            ArrayBlockingQueue q = populatedQueue(SIZE);
-            q.addAll(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-
-    /**
-     *  addAll of a collection with null elements throws NPE
-     */
-    public void testAddAll2() {
-        try {
-            ArrayBlockingQueue q = new ArrayBlockingQueue(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 {
-            ArrayBlockingQueue q = new ArrayBlockingQueue(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 {
-            ArrayBlockingQueue q = new ArrayBlockingQueue(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) {}
-    }
-    /**
-     * 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);
-        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() throws InterruptedException {
-        try {
-            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
-            q.put(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-     }
-
-    /**
-     * all elements successfully put are contained
-     */
-    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() throws InterruptedException {
-        final ArrayBlockingQueue q = new ArrayBlockingQueue(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 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() throws InterruptedException {
-        final ArrayBlockingQueue q = new ArrayBlockingQueue(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/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() 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() throws InterruptedException {
-        final ArrayBlockingQueue q = new ArrayBlockingQueue(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 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();
-    }
-
-
-    /**
-     * poll succeeds unless empty
-     */
-    public void testPoll() {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.poll());
-        }
-        assertNull(q.poll());
-    }
-
-    /**
-     * timed pool with zero timeout succeeds when non-empty, else times out
-     */
-    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() 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() 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() throws InterruptedException {
-        final ArrayBlockingQueue q = new ArrayBlockingQueue(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();
-    }
-
-
-    /**
-     * peek returns next element, or null if empty
-     */
-    public void testPeek() {
-        ArrayBlockingQueue q = populatedQueue(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());
-    }
-
-    /**
-     * element returns next element, or throws NSEE if empty
-     */
-    public void testElement() {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.element());
-            assertEquals(i, q.poll());
-        }
-        try {
-            q.element();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove removes next element, or throws NSEE if empty
-     */
-    public void testRemove() {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.remove());
-        }
-        try {
-            q.remove();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove(x) removes x and returns true if present
-     */
-    public void testRemoveElement() {
-        ArrayBlockingQueue q = populatedQueue(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() {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertTrue(q.contains(new Integer(i)));
-            assertEquals(i, q.poll());
-            assertFalse(q.contains(new Integer(i)));
-        }
-    }
-
-    /**
-     * clear removes all elements
-     */
-    public void testClear() {
-        ArrayBlockingQueue q = populatedQueue(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() {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        ArrayBlockingQueue p = new ArrayBlockingQueue(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() {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        ArrayBlockingQueue p = populatedQueue(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) {
-            ArrayBlockingQueue q = populatedQueue(SIZE);
-            ArrayBlockingQueue p = populatedQueue(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 {
-        ArrayBlockingQueue q = populatedQueue(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 {
-        ArrayBlockingQueue q = populatedQueue(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() {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        try {
-            Object o[] = q.toArray(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * toArray with incompatible array type throws CCE
-     */
-    public void testToArray1_BadArg() {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        try {
-            Object o[] = q.toArray(new String[10]);
-            shouldThrow();
-        } catch (ArrayStoreException success) {}
-    }
-
-
-    /**
-     * iterator iterates through all elements
-     */
-    public void testIterator() throws InterruptedException {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        Iterator it = q.iterator();
-        while (it.hasNext()) {
-            assertEquals(it.next(), q.take());
-        }
-    }
-
-    /**
-     * iterator.remove removes current element
-     */
-    public void testIteratorRemove () {
-        final ArrayBlockingQueue q = new ArrayBlockingQueue(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 ArrayBlockingQueue q = new ArrayBlockingQueue(3);
-        q.add(one);
-        q.add(two);
-        q.add(three);
-
-        assertEquals("queue should be full", 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 ArrayBlockingQueue q = new ArrayBlockingQueue(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());
-    }
-
-
-    /**
-     * toString contains toStrings of elements
-     */
-    public void testToString() {
-        ArrayBlockingQueue q = populatedQueue(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 ArrayBlockingQueue q = new ArrayBlockingQueue(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 ArrayBlockingQueue q = new ArrayBlockingQueue(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 queue has same elements in same order
-     */
-    public void testSerialization() throws Exception {
-        ArrayBlockingQueue q = populatedQueue(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));
-        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) {}
-    }
-
-    /**
-     * drainTo(this) throws IAE
-     */
-    public void testDrainToSelf() {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(q);
-            shouldThrow();
-        } 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)
-            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 queue, unblocking a waiting put.
-     */
-    public void testDrainToWithActivePut() throws InterruptedException {
-        final ArrayBlockingQueue q = populatedQueue(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() {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(null, 0);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * drainTo(this, n) throws IAE
-     */
-    public void testDrainToSelfN() {
-        ArrayBlockingQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(q, 0);
-            shouldThrow();
-        } 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++)
-                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/ArrayDequeTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/ArrayDequeTest.java
deleted file mode 100644
index cec1d58..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ArrayDequeTest.java
+++ /dev/null
@@ -1,630 +0,0 @@
-/*
- * 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
deleted file mode 100755
index b2d91b8..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicBooleanTest.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * 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.concurrent.atomic.*;
-import java.io.*;
-
-public class AtomicBooleanTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(AtomicBooleanTest.class);
-    }
-
-    /**
-     * constructor initializes to given value
-     */
-    public void testConstructor() {
-        assertTrue(new AtomicBoolean(true).get());
-        assertFalse(new AtomicBoolean(false).get());
-    }
-
-    /**
-     * default constructed initializes to false
-     */
-    public void testConstructor2() {
-        AtomicBoolean ai = new AtomicBoolean();
-        assertFalse(ai.get());
-    }
-
-    /**
-     * get returns the last value set
-     */
-    public void testGetSet() {
-        AtomicBoolean ai = new AtomicBoolean(true);
-        assertTrue(ai.get());
-        ai.set(false);
-        assertFalse(ai.get());
-        ai.set(true);
-        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());
-    }
-
-    /**
-     * compareAndSet succeeds in changing value if equal to expected else fails
-     */
-    public void testCompareAndSet() {
-        AtomicBoolean ai = new AtomicBoolean(true);
-        assertTrue(ai.compareAndSet(true,false));
-        assertFalse(ai.get());
-        assertTrue(ai.compareAndSet(false,false));
-        assertFalse(ai.get());
-        assertFalse(ai.compareAndSet(true,false));
-        assertFalse(ai.get());
-        assertTrue(ai.compareAndSet(false,true));
-        assertTrue(ai.get());
-    }
-
-    /**
-     * compareAndSet in one thread enables another waiting for value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws Exception {
-        final AtomicBoolean ai = new AtomicBoolean(true);
-        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
-     */
-    public void testWeakCompareAndSet() {
-        AtomicBoolean ai = new AtomicBoolean(true);
-        while (!ai.weakCompareAndSet(true,false));
-        assertFalse(ai.get());
-        while (!ai.weakCompareAndSet(false,false));
-        assertFalse(ai.get());
-        while (!ai.weakCompareAndSet(false,true));
-        assertTrue(ai.get());
-    }
-
-    /**
-     * getAndSet returns previous value and sets to given value
-     */
-    public void testGetAndSet() {
-        AtomicBoolean ai = new AtomicBoolean(true);
-        assertEquals(true,ai.getAndSet(false));
-        assertEquals(false,ai.getAndSet(false));
-        assertEquals(false,ai.getAndSet(true));
-        assertTrue(ai.get());
-    }
-
-    /**
-     * a deserialized serialized atomic holds same value
-     */
-    public void testSerialization() throws Exception {
-        AtomicBoolean l = new AtomicBoolean();
-
-        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();
-        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
deleted file mode 100644
index 838296d..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerArrayTest.java
+++ /dev/null
@@ -1,340 +0,0 @@
-/*
- * 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.concurrent.atomic.*;
-import java.io.*;
-import java.util.*;
-
-public class AtomicIntegerArrayTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(AtomicIntegerArrayTest.class);
-    }
-
-
-    /**
-     * constructor creates array of given size with all elements zero
-     */
-    public void testConstructor() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
-        for (int i = 0; i < SIZE; ++i)
-            assertEquals(0,ai.get(i));
-    }
-
-    /**
-     * constructor with null array throws NPE
-     */
-    public void testConstructor2NPE() {
-        try {
-            int[] a = null;
-            AtomicIntegerArray ai = new AtomicIntegerArray(a);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * constructor with array is of same size and has all elements
-     */
-    public void testConstructor2() {
-        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)
-            assertEquals(a[i], ai.get(i));
-    }
-
-    /**
-     * get and set for out of bound indices throw IndexOutOfBoundsException
-     */
-    public void testIndexing() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
-        try {
-            ai.get(SIZE);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-        try {
-            ai.get(-1);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-        try {
-            ai.set(SIZE, 0);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-        try {
-            ai.set(-1, 0);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-    }
-
-    /**
-     * get returns the last value set at index
-     */
-    public void testGetSet() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(1,ai.get(i));
-            ai.set(i, 2);
-            assertEquals(2,ai.get(i));
-            ai.set(i, -3);
-            assertEquals(-3,ai.get(i));
-        }
-    }
-
-    /**
-     * 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);
-        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));
-            assertEquals(-4,ai.get(i));
-            assertTrue(ai.compareAndSet(i, -4,7));
-            assertEquals(7,ai.get(i));
-        }
-    }
-
-    /**
-     * compareAndSet in one thread enables another waiting for value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws Exception {
-        final AtomicIntegerArray a = new AtomicIntegerArray(1);
-        a.set(0, 1);
-        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
-     */
-    public void testWeakCompareAndSet() {
-        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));
-            assertEquals(-4,ai.get(i));
-            while (!ai.weakCompareAndSet(i, -4,7));
-            assertEquals(7,ai.get(i));
-        }
-    }
-
-    /**
-     *  getAndSet returns previous value and sets to given value at given index
-     */
-    public void testGetAndSet() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(1,ai.getAndSet(i,0));
-            assertEquals(0,ai.getAndSet(i,-10));
-            assertEquals(-10,ai.getAndSet(i,1));
-        }
-    }
-
-    /**
-     *  getAndAdd returns previous value and adds given value
-     */
-    public void testGetAndAdd() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(1,ai.getAndAdd(i,2));
-            assertEquals(3,ai.get(i));
-            assertEquals(3,ai.getAndAdd(i,-4));
-            assertEquals(-1,ai.get(i));
-        }
-    }
-
-    /**
-     * getAndDecrement returns previous value and decrements
-     */
-    public void testGetAndDecrement() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(1,ai.getAndDecrement(i));
-            assertEquals(0,ai.getAndDecrement(i));
-            assertEquals(-1,ai.getAndDecrement(i));
-        }
-    }
-
-    /**
-     * getAndIncrement returns previous value and increments
-     */
-    public void testGetAndIncrement() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(1,ai.getAndIncrement(i));
-            assertEquals(2,ai.get(i));
-            ai.set(i,-2);
-            assertEquals(-2,ai.getAndIncrement(i));
-            assertEquals(-1,ai.getAndIncrement(i));
-            assertEquals(0,ai.getAndIncrement(i));
-            assertEquals(1,ai.get(i));
-        }
-    }
-
-    /**
-     *  addAndGet adds given value to current, and returns current value
-     */
-    public void testAddAndGet() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(3,ai.addAndGet(i,2));
-            assertEquals(3,ai.get(i));
-            assertEquals(-1,ai.addAndGet(i,-4));
-            assertEquals(-1,ai.get(i));
-        }
-    }
-
-    /**
-     * decrementAndGet decrements and returns current value
-     */
-    public void testDecrementAndGet() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(0,ai.decrementAndGet(i));
-            assertEquals(-1,ai.decrementAndGet(i));
-            assertEquals(-2,ai.decrementAndGet(i));
-            assertEquals(-2,ai.get(i));
-        }
-    }
-
-    /**
-     *  incrementAndGet increments and returns current value
-     */
-    public void testIncrementAndGet() {
-        AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(2,ai.incrementAndGet(i));
-            assertEquals(2,ai.get(i));
-            ai.set(i, -2);
-            assertEquals(-1,ai.incrementAndGet(i));
-            assertEquals(0,ai.incrementAndGet(i));
-            assertEquals(1,ai.incrementAndGet(i));
-            assertEquals(1,ai.get(i));
-        }
-    }
-
-    static final int COUNTDOWN = 100000;
-
-    class Counter implements Runnable {
-        final AtomicIntegerArray ai;
-        volatile int counts;
-        Counter(AtomicIntegerArray a) { ai = a; }
-        public void run() {
-            for (;;) {
-                boolean done = true;
-                for (int i = 0; i < ai.length(); ++i) {
-                    int v = ai.get(i);
-                    threadAssertTrue(v >= 0);
-                    if (v != 0) {
-                        done = false;
-                        if (ai.compareAndSet(i, v, v-1))
-                            ++counts;
-                    }
-                }
-                if (done)
-                    break;
-            }
-        }
-    }
-
-    /**
-     * Multiple threads using same array of counters successfully
-     * update a number of times equal to total count
-     */
-    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() throws Exception {
-        AtomicIntegerArray l = new AtomicIntegerArray(SIZE);
-        for (int i = 0; i < SIZE; ++i)
-            l.set(i, -i);
-
-        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));
-        }
-    }
-
-
-    /**
-     * toString returns current value.
-     */
-    public void testToString() {
-        int[] a = { 17, 3, -42, 99, -7};
-        AtomicIntegerArray ai = new AtomicIntegerArray(a);
-        assertEquals(Arrays.toString(a), ai.toString());
-    }
-
-}
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
deleted file mode 100755
index 383e30b..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerFieldUpdaterTest.java
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
- * 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.atomic.*;
-import junit.framework.*;
-import java.util.*;
-
-public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase {
-    volatile int x = 0;
-    int w;
-    long z;
-    public static Test suite() {
-        return new TestSuite(AtomicIntegerFieldUpdaterTest.class);
-    }
-
-    /**
-     * Construction with non-existent field throws RuntimeException
-     */
-    public void testConstructor() {
-        try {
-            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest>
-                a = AtomicIntegerFieldUpdater.newUpdater
-                (AtomicIntegerFieldUpdaterTest.class, "y");
-            shouldThrow();
-        } catch (RuntimeException success) {}
-    }
-
-    /**
-     * construction with field not of given type throws RuntimeException
-     */
-    public void testConstructor2() {
-        try {
-            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest>
-                a = AtomicIntegerFieldUpdater.newUpdater
-                (AtomicIntegerFieldUpdaterTest.class, "z");
-            shouldThrow();
-        } catch (RuntimeException success) {}
-    }
-
-    /**
-     * construction with non-volatile field throws RuntimeException
-     */
-    public void testConstructor3() {
-        try {
-            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest>
-                a = AtomicIntegerFieldUpdater.newUpdater
-                (AtomicIntegerFieldUpdaterTest.class, "w");
-            shouldThrow();
-        } catch (RuntimeException success) {}
-    }
-
-    /**
-     *  get returns the last value set or assigned
-     */
-    public void testGetSet() {
-        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
-        try {
-            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            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));
-    }
-
-    /**
-     *  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));
-    }
-
-    /**
-     * compareAndSet succeeds in changing value if equal to expected else fails
-     */
-    public void testCompareAndSet() {
-        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
-        try {
-            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertTrue(a.compareAndSet(this,1,2));
-        assertTrue(a.compareAndSet(this,2,-4));
-        assertEquals(-4,a.get(this));
-        assertFalse(a.compareAndSet(this,-5,7));
-        assertEquals(-4,a.get(this));
-        assertTrue(a.compareAndSet(this,-4,7));
-        assertEquals(7,a.get(this));
-    }
-
-
-    /**
-     * compareAndSet in one thread enables another waiting for value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws Exception {
-        x = 1;
-        final AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest>a;
-        try {
-            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-
-        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
-     */
-    public void testWeakCompareAndSet() {
-        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
-        try {
-            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        while (!a.weakCompareAndSet(this,1,2));
-        while (!a.weakCompareAndSet(this,2,-4));
-        assertEquals(-4,a.get(this));
-        while (!a.weakCompareAndSet(this,-4,7));
-        assertEquals(7,a.get(this));
-    }
-
-    /**
-     *  getAndSet returns previous value and sets to given value
-     */
-    public void testGetAndSet() {
-        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
-        try {
-            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(1,a.getAndSet(this, 0));
-        assertEquals(0,a.getAndSet(this,-10));
-        assertEquals(-10,a.getAndSet(this,1));
-    }
-
-    /**
-     * getAndAdd returns previous value and adds given value
-     */
-    public void testGetAndAdd() {
-        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
-        try {
-            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(1,a.getAndAdd(this,2));
-        assertEquals(3,a.get(this));
-        assertEquals(3,a.getAndAdd(this,-4));
-        assertEquals(-1,a.get(this));
-    }
-
-    /**
-     * getAndDecrement returns previous value and decrements
-     */
-    public void testGetAndDecrement() {
-        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
-        try {
-            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(1,a.getAndDecrement(this));
-        assertEquals(0,a.getAndDecrement(this));
-        assertEquals(-1,a.getAndDecrement(this));
-    }
-
-    /**
-     * getAndIncrement returns previous value and increments
-     */
-    public void testGetAndIncrement() {
-        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
-        try {
-            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(1,a.getAndIncrement(this));
-        assertEquals(2,a.get(this));
-        a.set(this,-2);
-        assertEquals(-2,a.getAndIncrement(this));
-        assertEquals(-1,a.getAndIncrement(this));
-        assertEquals(0,a.getAndIncrement(this));
-        assertEquals(1,a.get(this));
-    }
-
-    /**
-     * addAndGet adds given value to current, and returns current value
-     */
-    public void testAddAndGet() {
-        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
-        try {
-            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(3,a.addAndGet(this,2));
-        assertEquals(3,a.get(this));
-        assertEquals(-1,a.addAndGet(this,-4));
-        assertEquals(-1,a.get(this));
-    }
-
-    /**
-     * decrementAndGet decrements and returns current value
-     */
-    public void testDecrementAndGet() {
-        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
-        try {
-            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(0,a.decrementAndGet(this));
-        assertEquals(-1,a.decrementAndGet(this));
-        assertEquals(-2,a.decrementAndGet(this));
-        assertEquals(-2,a.get(this));
-    }
-
-    /**
-     * incrementAndGet increments and returns current value
-     */
-    public void testIncrementAndGet() {
-        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
-        try {
-            a = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(2,a.incrementAndGet(this));
-        assertEquals(2,a.get(this));
-        a.set(this,-2);
-        assertEquals(-1,a.incrementAndGet(this));
-        assertEquals(0,a.incrementAndGet(this));
-        assertEquals(1,a.incrementAndGet(this));
-        assertEquals(1,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
deleted file mode 100755
index a2f3b4b..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicIntegerTest.java
+++ /dev/null
@@ -1,269 +0,0 @@
-/*
- * 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.concurrent.atomic.*;
-import java.io.*;
-
-public class AtomicIntegerTest extends JSR166TestCase {
-    public static Test suite() {
-        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() {
-        AtomicInteger ai = new AtomicInteger(1);
-        assertEquals(1,ai.get());
-    }
-
-    /**
-     * default constructed initializes to zero
-     */
-    public void testConstructor2() {
-        AtomicInteger ai = new AtomicInteger();
-        assertEquals(0,ai.get());
-    }
-
-    /**
-     * get returns the last value set
-     */
-    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() {
-        AtomicInteger ai = new AtomicInteger(1);
-        assertTrue(ai.compareAndSet(1,2));
-        assertTrue(ai.compareAndSet(2,-4));
-        assertEquals(-4,ai.get());
-        assertFalse(ai.compareAndSet(-5,7));
-        assertEquals(-4,ai.get());
-        assertTrue(ai.compareAndSet(-4,7));
-        assertEquals(7,ai.get());
-    }
-
-    /**
-     * compareAndSet in one thread enables another waiting for value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws Exception {
-        final AtomicInteger ai = new AtomicInteger(1);
-        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
-     */
-    public void testWeakCompareAndSet() {
-        AtomicInteger ai = new AtomicInteger(1);
-        while (!ai.weakCompareAndSet(1,2));
-        while (!ai.weakCompareAndSet(2,-4));
-        assertEquals(-4,ai.get());
-        while (!ai.weakCompareAndSet(-4,7));
-        assertEquals(7,ai.get());
-    }
-
-    /**
-     * getAndSet returns previous value and sets to given value
-     */
-    public void testGetAndSet() {
-        AtomicInteger ai = new AtomicInteger(1);
-        assertEquals(1,ai.getAndSet(0));
-        assertEquals(0,ai.getAndSet(-10));
-        assertEquals(-10,ai.getAndSet(1));
-    }
-
-    /**
-     * getAndAdd returns previous value and adds given value
-     */
-    public void testGetAndAdd() {
-        AtomicInteger ai = new AtomicInteger(1);
-        assertEquals(1,ai.getAndAdd(2));
-        assertEquals(3,ai.get());
-        assertEquals(3,ai.getAndAdd(-4));
-        assertEquals(-1,ai.get());
-    }
-
-    /**
-     * getAndDecrement returns previous value and decrements
-     */
-    public void testGetAndDecrement() {
-        AtomicInteger ai = new AtomicInteger(1);
-        assertEquals(1,ai.getAndDecrement());
-        assertEquals(0,ai.getAndDecrement());
-        assertEquals(-1,ai.getAndDecrement());
-    }
-
-    /**
-     * getAndIncrement returns previous value and increments
-     */
-    public void testGetAndIncrement() {
-        AtomicInteger ai = new AtomicInteger(1);
-        assertEquals(1,ai.getAndIncrement());
-        assertEquals(2,ai.get());
-        ai.set(-2);
-        assertEquals(-2,ai.getAndIncrement());
-        assertEquals(-1,ai.getAndIncrement());
-        assertEquals(0,ai.getAndIncrement());
-        assertEquals(1,ai.get());
-    }
-
-    /**
-     * addAndGet adds given value to current, and returns current value
-     */
-    public void testAddAndGet() {
-        AtomicInteger ai = new AtomicInteger(1);
-        assertEquals(3,ai.addAndGet(2));
-        assertEquals(3,ai.get());
-        assertEquals(-1,ai.addAndGet(-4));
-        assertEquals(-1,ai.get());
-    }
-
-    /**
-     * decrementAndGet decrements and returns current value
-     */
-    public void testDecrementAndGet() {
-        AtomicInteger ai = new AtomicInteger(1);
-        assertEquals(0,ai.decrementAndGet());
-        assertEquals(-1,ai.decrementAndGet());
-        assertEquals(-2,ai.decrementAndGet());
-        assertEquals(-2,ai.get());
-    }
-
-    /**
-     * incrementAndGet increments and returns current value
-     */
-    public void testIncrementAndGet() {
-        AtomicInteger ai = new AtomicInteger(1);
-        assertEquals(2,ai.incrementAndGet());
-        assertEquals(2,ai.get());
-        ai.set(-2);
-        assertEquals(-1,ai.incrementAndGet());
-        assertEquals(0,ai.incrementAndGet());
-        assertEquals(1,ai.incrementAndGet());
-        assertEquals(1,ai.get());
-    }
-
-    /**
-     * a deserialized serialized atomic holds same value
-     */
-    public void testSerialization() throws Exception {
-        AtomicInteger l = new AtomicInteger();
-
-        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());
-    }
-
-    /**
-     * toString returns current value.
-     */
-    public void testToString() {
-        AtomicInteger ai = new AtomicInteger();
-        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();
-        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();
-        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();
-        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();
-        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
deleted file mode 100644
index 88e0984..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongArrayTest.java
+++ /dev/null
@@ -1,338 +0,0 @@
-/*
- * 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.concurrent.atomic.*;
-import java.io.*;
-import java.util.*;
-
-public class AtomicLongArrayTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(AtomicLongArrayTest.class);
-    }
-
-    /**
-     * constructor creates array of given size with all elements zero
-     */
-    public void testConstructor() {
-        AtomicLongArray ai = new AtomicLongArray(SIZE);
-        for (int i = 0; i < SIZE; ++i)
-            assertEquals(0,ai.get(i));
-    }
-
-    /**
-     * constructor with null array throws NPE
-     */
-    public void testConstructor2NPE() {
-        try {
-            long[] a = null;
-            AtomicLongArray ai = new AtomicLongArray(a);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * constructor with array is of same size and has all elements
-     */
-    public void testConstructor2() {
-        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)
-            assertEquals(a[i], ai.get(i));
-    }
-
-    /**
-     * get and set for out of bound indices throw IndexOutOfBoundsException
-     */
-    public void testIndexing() {
-        AtomicLongArray ai = new AtomicLongArray(SIZE);
-        try {
-            ai.get(SIZE);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-        try {
-            ai.get(-1);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-        try {
-            ai.set(SIZE, 0);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-        try {
-            ai.set(-1, 0);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-    }
-
-    /**
-     * get returns the last value set at index
-     */
-    public void testGetSet() {
-        AtomicLongArray ai = new AtomicLongArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(1,ai.get(i));
-            ai.set(i, 2);
-            assertEquals(2,ai.get(i));
-            ai.set(i, -3);
-            assertEquals(-3,ai.get(i));
-        }
-    }
-
-    /**
-     * 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);
-        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));
-            assertEquals(-4,ai.get(i));
-            assertTrue(ai.compareAndSet(i, -4,7));
-            assertEquals(7,ai.get(i));
-        }
-    }
-
-    /**
-     * compareAndSet in one thread enables another waiting for value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws InterruptedException {
-        final AtomicLongArray a = new AtomicLongArray(1);
-        a.set(0, 1);
-        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
-     */
-    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));
-            assertEquals(-4,ai.get(i));
-            while (!ai.weakCompareAndSet(i, -4,7));
-            assertEquals(7,ai.get(i));
-        }
-    }
-
-    /**
-     *  getAndSet returns previous value and sets to given value at given index
-     */
-    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));
-            assertEquals(0,ai.getAndSet(i,-10));
-            assertEquals(-10,ai.getAndSet(i,1));
-        }
-    }
-
-    /**
-     *  getAndAdd returns previous value and adds given value
-     */
-    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));
-            assertEquals(3,ai.get(i));
-            assertEquals(3,ai.getAndAdd(i,-4));
-            assertEquals(-1,ai.get(i));
-        }
-    }
-
-    /**
-     * getAndDecrement returns previous value and decrements
-     */
-    public void testGetAndDecrement() {
-        AtomicLongArray ai = new AtomicLongArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(1,ai.getAndDecrement(i));
-            assertEquals(0,ai.getAndDecrement(i));
-            assertEquals(-1,ai.getAndDecrement(i));
-        }
-    }
-
-    /**
-     * getAndIncrement returns previous value and increments
-     */
-    public void testGetAndIncrement() {
-        AtomicLongArray ai = new AtomicLongArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(1,ai.getAndIncrement(i));
-            assertEquals(2,ai.get(i));
-            ai.set(i,-2);
-            assertEquals(-2,ai.getAndIncrement(i));
-            assertEquals(-1,ai.getAndIncrement(i));
-            assertEquals(0,ai.getAndIncrement(i));
-            assertEquals(1,ai.get(i));
-        }
-    }
-
-    /**
-     *  addAndGet adds given value to current, and returns current value
-     */
-    public void testAddAndGet() {
-        AtomicLongArray ai = new AtomicLongArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(3,ai.addAndGet(i,2));
-            assertEquals(3,ai.get(i));
-            assertEquals(-1,ai.addAndGet(i,-4));
-            assertEquals(-1,ai.get(i));
-        }
-    }
-
-    /**
-     * decrementAndGet decrements and returns current value
-     */
-    public void testDecrementAndGet() {
-        AtomicLongArray ai = new AtomicLongArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(0,ai.decrementAndGet(i));
-            assertEquals(-1,ai.decrementAndGet(i));
-            assertEquals(-2,ai.decrementAndGet(i));
-            assertEquals(-2,ai.get(i));
-        }
-    }
-
-    /**
-     * incrementAndGet increments and returns current value
-     */
-    public void testIncrementAndGet() {
-        AtomicLongArray ai = new AtomicLongArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, 1);
-            assertEquals(2,ai.incrementAndGet(i));
-            assertEquals(2,ai.get(i));
-            ai.set(i, -2);
-            assertEquals(-1,ai.incrementAndGet(i));
-            assertEquals(0,ai.incrementAndGet(i));
-            assertEquals(1,ai.incrementAndGet(i));
-            assertEquals(1,ai.get(i));
-        }
-    }
-
-    static final long COUNTDOWN = 100000;
-
-    class Counter implements Runnable {
-        final AtomicLongArray ai;
-        volatile long counts;
-        Counter(AtomicLongArray a) { ai = a; }
-        public void run() {
-            for (;;) {
-                boolean done = true;
-                for (int i = 0; i < ai.length(); ++i) {
-                    long v = ai.get(i);
-                    threadAssertTrue(v >= 0);
-                    if (v != 0) {
-                        done = false;
-                        if (ai.compareAndSet(i, v, v-1))
-                            ++counts;
-                    }
-                }
-                if (done)
-                    break;
-            }
-        }
-    }
-
-    /**
-     * Multiple threads using same array of counters successfully
-     * update a number of times equal to total count
-     */
-    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() throws Exception {
-        AtomicLongArray l = new AtomicLongArray(SIZE);
-        for (int i = 0; i < SIZE; ++i)
-            l.set(i, -i);
-
-        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));
-        }
-    }
-
-    /**
-     * toString returns current value.
-     */
-    public void testToString() {
-        long[] a = { 17, 3, -42, 99, -7};
-        AtomicLongArray ai = new AtomicLongArray(a);
-        assertEquals(Arrays.toString(a), ai.toString());
-    }
-
-
-}
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
deleted file mode 100755
index 491baf4..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongFieldUpdaterTest.java
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
- * 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.atomic.*;
-import junit.framework.*;
-import java.util.*;
-
-public class AtomicLongFieldUpdaterTest extends JSR166TestCase {
-    volatile long x = 0;
-    int z;
-    long w;
-
-    public static Test suite() {
-        return new TestSuite(AtomicLongFieldUpdaterTest.class);
-    }
-
-    /**
-     * Construction with non-existent field throws RuntimeException
-     */
-    public void testConstructor() {
-        try {
-            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>
-                a = AtomicLongFieldUpdater.newUpdater
-                (AtomicLongFieldUpdaterTest.class, "y");
-            shouldThrow();
-        } catch (RuntimeException success) {}
-    }
-
-    /**
-     * construction with field not of given type throws RuntimeException
-     */
-    public void testConstructor2() {
-        try {
-            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>
-                a = AtomicLongFieldUpdater.newUpdater
-                (AtomicLongFieldUpdaterTest.class, "z");
-            shouldThrow();
-        } catch (RuntimeException success) {}
-    }
-
-    /**
-     * construction with non-volatile field throws RuntimeException
-     */
-    public void testConstructor3() {
-        try {
-            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>
-                a = AtomicLongFieldUpdater.newUpdater
-                (AtomicLongFieldUpdaterTest.class, "w");
-            shouldThrow();
-        } catch (RuntimeException success) {}
-    }
-
-    /**
-     *  get returns the last value set or assigned
-     */
-    public void testGetSet() {
-        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            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));
-    }
-
-    /**
-     *  get returns the last value lazySet by same thread
-     */
-    public void testGetLazySet() {
-        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.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));
-    }
-
-
-    /**
-     * compareAndSet succeeds in changing value if equal to expected else fails
-     */
-    public void testCompareAndSet() {
-        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertTrue(a.compareAndSet(this,1,2));
-        assertTrue(a.compareAndSet(this,2,-4));
-        assertEquals(-4,a.get(this));
-        assertFalse(a.compareAndSet(this,-5,7));
-        assertEquals(-4,a.get(this));
-        assertTrue(a.compareAndSet(this,-4,7));
-        assertEquals(7,a.get(this));
-    }
-
-
-    /**
-     * compareAndSet in one thread enables another waiting for value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws Exception {
-        x = 1;
-        final AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest>a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-
-        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() {
-        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        while (!a.weakCompareAndSet(this,1,2));
-        while (!a.weakCompareAndSet(this,2,-4));
-        assertEquals(-4,a.get(this));
-        while (!a.weakCompareAndSet(this,-4,7));
-        assertEquals(7,a.get(this));
-    }
-
-    /**
-     *  getAndSet returns previous value and sets to given value
-     */
-    public void testGetAndSet() {
-        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(1,a.getAndSet(this, 0));
-        assertEquals(0,a.getAndSet(this,-10));
-        assertEquals(-10,a.getAndSet(this,1));
-    }
-
-    /**
-     * getAndAdd returns previous value and adds given value
-     */
-    public void testGetAndAdd() {
-        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(1,a.getAndAdd(this,2));
-        assertEquals(3,a.get(this));
-        assertEquals(3,a.getAndAdd(this,-4));
-        assertEquals(-1,a.get(this));
-    }
-
-    /**
-     * getAndDecrement returns previous value and decrements
-     */
-    public void testGetAndDecrement() {
-        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(1,a.getAndDecrement(this));
-        assertEquals(0,a.getAndDecrement(this));
-        assertEquals(-1,a.getAndDecrement(this));
-    }
-
-    /**
-     * getAndIncrement returns previous value and increments
-     */
-    public void testGetAndIncrement() {
-        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(1,a.getAndIncrement(this));
-        assertEquals(2,a.get(this));
-        a.set(this,-2);
-        assertEquals(-2,a.getAndIncrement(this));
-        assertEquals(-1,a.getAndIncrement(this));
-        assertEquals(0,a.getAndIncrement(this));
-        assertEquals(1,a.get(this));
-    }
-
-    /**
-     * addAndGet adds given value to current, and returns current value
-     */
-    public void testAddAndGet() {
-        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(3,a.addAndGet(this,2));
-        assertEquals(3,a.get(this));
-        assertEquals(-1,a.addAndGet(this,-4));
-        assertEquals(-1,a.get(this));
-    }
-
-    /**
-     *  decrementAndGet decrements and returns current value
-     */
-    public void testDecrementAndGet() {
-        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(0,a.decrementAndGet(this));
-        assertEquals(-1,a.decrementAndGet(this));
-        assertEquals(-2,a.decrementAndGet(this));
-        assertEquals(-2,a.get(this));
-    }
-
-    /**
-     * incrementAndGet increments and returns current value
-     */
-    public void testIncrementAndGet() {
-        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
-        try {
-            a = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterTest.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = 1;
-        assertEquals(2,a.incrementAndGet(this));
-        assertEquals(2,a.get(this));
-        a.set(this,-2);
-        assertEquals(-1,a.incrementAndGet(this));
-        assertEquals(0,a.incrementAndGet(this));
-        assertEquals(1,a.incrementAndGet(this));
-        assertEquals(1,a.get(this));
-    }
-
-}
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
deleted file mode 100755
index e73e86e..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicLongTest.java
+++ /dev/null
@@ -1,271 +0,0 @@
-/*
- * 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.concurrent.atomic.*;
-import java.io.*;
-
-public class AtomicLongTest extends JSR166TestCase {
-    public static Test suite() {
-        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() {
-        AtomicLong ai = new AtomicLong(1);
-        assertEquals(1,ai.get());
-    }
-
-    /**
-     * default constructed initializes to zero
-     */
-    public void testConstructor2() {
-        AtomicLong ai = new AtomicLong();
-        assertEquals(0,ai.get());
-    }
-
-    /**
-     * get returns the last value set
-     */
-    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() {
-        AtomicLong ai = new AtomicLong(1);
-        assertTrue(ai.compareAndSet(1,2));
-        assertTrue(ai.compareAndSet(2,-4));
-        assertEquals(-4,ai.get());
-        assertFalse(ai.compareAndSet(-5,7));
-        assertEquals(-4,ai.get());
-        assertTrue(ai.compareAndSet(-4,7));
-        assertEquals(7,ai.get());
-    }
-
-    /**
-     * compareAndSet in one thread enables another waiting for value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws Exception {
-        final AtomicLong ai = new AtomicLong(1);
-        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
-     */
-    public void testWeakCompareAndSet() {
-        AtomicLong ai = new AtomicLong(1);
-        while (!ai.weakCompareAndSet(1,2));
-        while (!ai.weakCompareAndSet(2,-4));
-        assertEquals(-4,ai.get());
-        while (!ai.weakCompareAndSet(-4,7));
-        assertEquals(7,ai.get());
-    }
-
-    /**
-     * getAndSet returns previous value and sets to given value
-     */
-    public void testGetAndSet() {
-        AtomicLong ai = new AtomicLong(1);
-        assertEquals(1,ai.getAndSet(0));
-        assertEquals(0,ai.getAndSet(-10));
-        assertEquals(-10,ai.getAndSet(1));
-    }
-
-    /**
-     * getAndAdd returns previous value and adds given value
-     */
-    public void testGetAndAdd() {
-        AtomicLong ai = new AtomicLong(1);
-        assertEquals(1,ai.getAndAdd(2));
-        assertEquals(3,ai.get());
-        assertEquals(3,ai.getAndAdd(-4));
-        assertEquals(-1,ai.get());
-    }
-
-    /**
-     * getAndDecrement returns previous value and decrements
-     */
-    public void testGetAndDecrement() {
-        AtomicLong ai = new AtomicLong(1);
-        assertEquals(1,ai.getAndDecrement());
-        assertEquals(0,ai.getAndDecrement());
-        assertEquals(-1,ai.getAndDecrement());
-    }
-
-    /**
-     * getAndIncrement returns previous value and increments
-     */
-    public void testGetAndIncrement() {
-        AtomicLong ai = new AtomicLong(1);
-        assertEquals(1,ai.getAndIncrement());
-        assertEquals(2,ai.get());
-        ai.set(-2);
-        assertEquals(-2,ai.getAndIncrement());
-        assertEquals(-1,ai.getAndIncrement());
-        assertEquals(0,ai.getAndIncrement());
-        assertEquals(1,ai.get());
-    }
-
-    /**
-     * addAndGet adds given value to current, and returns current value
-     */
-    public void testAddAndGet() {
-        AtomicLong ai = new AtomicLong(1);
-        assertEquals(3,ai.addAndGet(2));
-        assertEquals(3,ai.get());
-        assertEquals(-1,ai.addAndGet(-4));
-        assertEquals(-1,ai.get());
-    }
-
-    /**
-     * decrementAndGet decrements and returns current value
-     */
-    public void testDecrementAndGet() {
-        AtomicLong ai = new AtomicLong(1);
-        assertEquals(0,ai.decrementAndGet());
-        assertEquals(-1,ai.decrementAndGet());
-        assertEquals(-2,ai.decrementAndGet());
-        assertEquals(-2,ai.get());
-    }
-
-    /**
-     * incrementAndGet increments and returns current value
-     */
-    public void testIncrementAndGet() {
-        AtomicLong ai = new AtomicLong(1);
-        assertEquals(2,ai.incrementAndGet());
-        assertEquals(2,ai.get());
-        ai.set(-2);
-        assertEquals(-1,ai.incrementAndGet());
-        assertEquals(0,ai.incrementAndGet());
-        assertEquals(1,ai.incrementAndGet());
-        assertEquals(1,ai.get());
-    }
-
-    /**
-     * a deserialized serialized atomic holds same value
-     */
-    public void testSerialization() throws Exception {
-        AtomicLong l = new AtomicLong();
-
-        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();
-        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();
-        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();
-        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();
-        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
deleted file mode 100755
index 72a2337..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicMarkableReferenceTest.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * 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.concurrent.atomic.*;
-
-public class AtomicMarkableReferenceTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(AtomicMarkableReferenceTest.class);
-    }
-
-    /**
-     *  constructor initializes to given reference and mark
-     */
-    public void testConstructor() {
-        AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
-        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() {
-        boolean[] mark = new boolean[1];
-        AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
-        assertSame(one,ai.getReference());
-        assertFalse(ai.isMarked());
-        assertSame(one, ai.get(mark));
-        assertFalse(mark[0]);
-        ai.set(two, false);
-        assertSame(two,ai.getReference());
-        assertFalse(ai.isMarked());
-        assertSame(two, ai.get(mark));
-        assertFalse(mark[0]);
-        ai.set(one, true);
-        assertSame(one,ai.getReference());
-        assertTrue(ai.isMarked());
-        assertSame(one, ai.get(mark));
-        assertTrue(mark[0]);
-    }
-
-    /**
-     * attemptMark succeeds in single thread
-     */
-    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());
-        assertSame(one, ai.get(mark));
-        assertTrue(mark[0]);
-    }
-
-    /**
-     * compareAndSet succeeds in changing values if equal to expected reference
-     * and mark else fails
-     */
-    public void testCompareAndSet() {
-        boolean[] mark = new boolean[1];
-        AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
-        assertSame(one, ai.get(mark));
-        assertFalse(ai.isMarked());
-        assertFalse(mark[0]);
-
-        assertTrue(ai.compareAndSet(one, two, false, false));
-        assertSame(two, ai.get(mark));
-        assertFalse(mark[0]);
-
-        assertTrue(ai.compareAndSet(two, m3, false, true));
-        assertSame(m3, ai.get(mark));
-        assertTrue(mark[0]);
-
-        assertFalse(ai.compareAndSet(two, m3, true, true));
-        assertSame(m3, ai.get(mark));
-        assertTrue(mark[0]);
-    }
-
-    /**
-     * compareAndSet in one thread enables another waiting for reference value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws Exception {
-        final AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
-        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() throws Exception {
-        final AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
-        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
-     */
-    public void testWeakCompareAndSet() {
-        boolean[] mark = new boolean[1];
-        AtomicMarkableReference ai = new AtomicMarkableReference(one, false);
-        assertSame(one, ai.get(mark));
-        assertFalse(ai.isMarked());
-        assertFalse(mark[0]);
-
-        while (!ai.weakCompareAndSet(one, two, false, false));
-        assertSame(two, ai.get(mark));
-        assertFalse(mark[0]);
-
-        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
deleted file mode 100644
index 25f8474..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceArrayTest.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * 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.concurrent.atomic.*;
-import java.io.*;
-import java.util.*;
-
-public class AtomicReferenceArrayTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(AtomicReferenceArrayTest.class);
-    }
-
-    /**
-     * constructor creates array of given size with all elements null
-     */
-    public void testConstructor() {
-        AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertNull(ai.get(i));
-        }
-    }
-
-    /**
-     * constructor with null array throws NPE
-     */
-    public void testConstructor2NPE() {
-        try {
-            Integer[] a = null;
-            AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(a);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * constructor with array is of same size and has all elements
-     */
-    public void testConstructor2() {
-        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)
-            assertEquals(a[i], ai.get(i));
-    }
-
-
-    /**
-     * get and set for out of bound indices throw IndexOutOfBoundsException
-     */
-    public void testIndexing() {
-        AtomicReferenceArray<Integer> ai = new AtomicReferenceArray<Integer>(SIZE);
-        try {
-            ai.get(SIZE);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-        try {
-            ai.get(-1);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-        try {
-            ai.set(SIZE, null);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-        try {
-            ai.set(-1, null);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {
-        }
-    }
-
-    /**
-     * get returns the last value set at index
-     */
-    public void testGetSet() {
-        AtomicReferenceArray ai = new AtomicReferenceArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, one);
-            assertSame(one,ai.get(i));
-            ai.set(i, two);
-            assertSame(two,ai.get(i));
-            ai.set(i, m3);
-            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);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(i, one);
-            assertTrue(ai.compareAndSet(i, one,two));
-            assertTrue(ai.compareAndSet(i, two,m4));
-            assertSame(m4,ai.get(i));
-            assertFalse(ai.compareAndSet(i, m5,seven));
-            assertSame(m4,ai.get(i));
-            assertTrue(ai.compareAndSet(i, m4,seven));
-            assertSame(seven,ai.get(i));
-        }
-    }
-
-    /**
-     * compareAndSet in one thread enables another waiting for value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws InterruptedException {
-        final AtomicReferenceArray a = new AtomicReferenceArray(1);
-        a.set(0, one);
-        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
-     */
-    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));
-            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);
-        for (int i = 0; i < SIZE; ++i) {
-            ai.set(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() throws Exception {
-        AtomicReferenceArray l = new AtomicReferenceArray(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            l.set(i, new Integer(-i));
-        }
-
-        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);
-        assertEquals(Arrays.toString(a), ai.toString());
-    }
-}
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
deleted file mode 100755
index 78c321e..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceFieldUpdaterTest.java
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * 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.atomic.*;
-import junit.framework.*;
-import java.util.*;
-
-public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase {
-    volatile Integer x = null;
-    Object z;
-    Integer w;
-
-    public static Test suite() {
-        return new TestSuite(AtomicReferenceFieldUpdaterTest.class);
-    }
-
-    /**
-     * Construction with non-existent field throws RuntimeException
-     */
-    public void testConstructor() {
-        try {
-            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
-                a = AtomicReferenceFieldUpdater.newUpdater
-                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "y");
-            shouldThrow();
-        } catch (RuntimeException success) {}
-    }
-
-
-    /**
-     * construction with field not of given type throws RuntimeException
-     */
-    public void testConstructor2() {
-        try {
-            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
-                a = AtomicReferenceFieldUpdater.newUpdater
-                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "z");
-            shouldThrow();
-        } catch (RuntimeException success) {}
-    }
-
-    /**
-     * Constructor with non-volatile field throws exception
-     */
-    public void testConstructor3() {
-        try {
-            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>
-                a = AtomicReferenceFieldUpdater.newUpdater
-                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "w");
-            shouldThrow();
-        } catch (RuntimeException success) {}
-    }
-
-    /**
-     *  get returns the last value set or assigned
-     */
-    public void testGetSet() {
-        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
-        try {
-            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        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 lazySet by same thread
-     */
-    public void testGetLazySet() {
-        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
-        try {
-            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = one;
-        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() {
-        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
-        try {
-            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = one;
-        assertTrue(a.compareAndSet(this,one,two));
-        assertTrue(a.compareAndSet(this,two,m4));
-        assertSame(m4,a.get(this));
-        assertFalse(a.compareAndSet(this,m5,seven));
-        assertFalse(seven == a.get(this));
-        assertTrue(a.compareAndSet(this,m4,seven));
-        assertSame(seven,a.get(this));
-    }
-
-    /**
-     * compareAndSet in one thread enables another waiting for value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws Exception {
-        x = one;
-        final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
-        try {
-            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-
-        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() {
-        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
-        try {
-            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = one;
-        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() {
-        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
-        try {
-            a = AtomicReferenceFieldUpdater.newUpdater(AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
-        } catch (RuntimeException ok) {
-            return;
-        }
-        x = one;
-        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
deleted file mode 100755
index 5046ee8..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicReferenceTest.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * 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.concurrent.atomic.*;
-import java.io.*;
-
-public class AtomicReferenceTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(AtomicReferenceTest.class);
-    }
-
-    /**
-     * constructor initializes to given value
-     */
-    public void testConstructor() {
-        AtomicReference ai = new AtomicReference(one);
-        assertSame(one,ai.get());
-    }
-
-    /**
-     * default constructed initializes to null
-     */
-    public void testConstructor2() {
-        AtomicReference ai = new AtomicReference();
-        assertNull(ai.get());
-    }
-
-    /**
-     * get returns the last value set
-     */
-    public void testGetSet() {
-        AtomicReference ai = new AtomicReference(one);
-        assertSame(one,ai.get());
-        ai.set(two);
-        assertSame(two,ai.get());
-        ai.set(m3);
-        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() {
-        AtomicReference ai = new AtomicReference(one);
-        assertTrue(ai.compareAndSet(one,two));
-        assertTrue(ai.compareAndSet(two,m4));
-        assertSame(m4,ai.get());
-        assertFalse(ai.compareAndSet(m5,seven));
-        assertSame(m4,ai.get());
-        assertTrue(ai.compareAndSet(m4,seven));
-        assertSame(seven,ai.get());
-    }
-
-    /**
-     * compareAndSet in one thread enables another waiting for value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws Exception {
-        final AtomicReference ai = new AtomicReference(one);
-        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() {
-        AtomicReference ai = new AtomicReference(one);
-        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() {
-        AtomicReference ai = new AtomicReference(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() throws Exception {
-        AtomicReference l = new AtomicReference();
-
-        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);
-        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
deleted file mode 100755
index ca9b724..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/AtomicStampedReferenceTest.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * 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.concurrent.atomic.*;
-
-public class AtomicStampedReferenceTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(AtomicStampedReferenceTest.class);
-    }
-
-    /**
-     * constructor initializes to given reference and stamp
-     */
-    public void testConstructor() {
-        AtomicStampedReference ai = new AtomicStampedReference(one, 0);
-        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() {
-        int[] mark = new int[1];
-        AtomicStampedReference ai = new AtomicStampedReference(one, 0);
-        assertSame(one,ai.getReference());
-        assertEquals(0, ai.getStamp());
-        assertSame(one, ai.get(mark));
-        assertEquals(0, mark[0]);
-        ai.set(two, 0);
-        assertSame(two,ai.getReference());
-        assertEquals(0, ai.getStamp());
-        assertSame(two, ai.get(mark));
-        assertEquals(0, mark[0]);
-        ai.set(one, 1);
-        assertSame(one,ai.getReference());
-        assertEquals(1, ai.getStamp());
-        assertSame(one, ai.get(mark));
-        assertEquals(1,mark[0]);
-    }
-
-    /**
-     *  attemptStamp succeeds in single thread
-     */
-    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());
-        assertSame(one, ai.get(mark));
-        assertEquals(1, mark[0]);
-    }
-
-    /**
-     * compareAndSet succeeds in changing values if equal to expected reference
-     * and stamp else fails
-     */
-    public void testCompareAndSet() {
-        int[] mark = new int[1];
-        AtomicStampedReference ai = new AtomicStampedReference(one, 0);
-        assertSame(one, ai.get(mark));
-        assertEquals(0, ai.getStamp());
-        assertEquals(0, mark[0]);
-
-        assertTrue(ai.compareAndSet(one, two, 0, 0));
-        assertSame(two, ai.get(mark));
-        assertEquals(0, mark[0]);
-
-        assertTrue(ai.compareAndSet(two, m3, 0, 1));
-        assertSame(m3, ai.get(mark));
-        assertEquals(1, mark[0]);
-
-        assertFalse(ai.compareAndSet(two, m3, 1, 1));
-        assertSame(m3, ai.get(mark));
-        assertEquals(1, mark[0]);
-    }
-
-    /**
-     * compareAndSet in one thread enables another waiting for reference value
-     * to succeed
-     */
-    public void testCompareAndSetInMultipleThreads() throws Exception {
-        final AtomicStampedReference ai = new AtomicStampedReference(one, 0);
-        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() throws Exception {
-        final AtomicStampedReference ai = new AtomicStampedReference(one, 0);
-        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
-     */
-    public void testWeakCompareAndSet() {
-        int[] mark = new int[1];
-        AtomicStampedReference ai = new AtomicStampedReference(one, 0);
-        assertSame(one, ai.get(mark));
-        assertEquals(0, ai.getStamp ());
-        assertEquals(0, mark[0]);
-
-        while (!ai.weakCompareAndSet(one, two, 0, 0));
-        assertSame(two, ai.get(mark));
-        assertEquals(0, mark[0]);
-
-        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
deleted file mode 100755
index 9b355f5..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentHashMapTest.java
+++ /dev/null
@@ -1,596 +0,0 @@
-/*
- * 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 java.util.Enumeration;
-import java.io.*;
-
-public class ConcurrentHashMapTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(ConcurrentHashMapTest.class);
-    }
-
-    /**
-     * Create a map from Integers 1-5 to Strings "A"-"E".
-     */
-    private static ConcurrentHashMap map5() {
-        ConcurrentHashMap map = new ConcurrentHashMap(5);
-        assertTrue(map.isEmpty());
-        map.put(one, "A");
-        map.put(two, "B");
-        map.put(three, "C");
-        map.put(four, "D");
-        map.put(five, "E");
-        assertFalse(map.isEmpty());
-        assertEquals(5, map.size());
-        return map;
-    }
-
-    /**
-     *  clear removes all pairs
-     */
-    public void testClear() {
-        ConcurrentHashMap map = map5();
-        map.clear();
-        assertEquals(map.size(), 0);
-    }
-
-    /**
-     *  Maps with same contents are equal
-     */
-    public void testEquals() {
-        ConcurrentHashMap map1 = map5();
-        ConcurrentHashMap map2 = map5();
-        assertEquals(map1, map2);
-        assertEquals(map2, map1);
-        map1.clear();
-        assertFalse(map1.equals(map2));
-        assertFalse(map2.equals(map1));
-    }
-
-    /**
-     *  contains returns true for contained value
-     */
-    public void testContains() {
-        ConcurrentHashMap map = map5();
-        assertTrue(map.contains("A"));
-        assertFalse(map.contains("Z"));
-    }
-
-    /**
-     *  containsKey returns true for contained key
-     */
-    public void testContainsKey() {
-        ConcurrentHashMap map = map5();
-        assertTrue(map.containsKey(one));
-        assertFalse(map.containsKey(zero));
-    }
-
-    /**
-     *  containsValue returns true for held values
-     */
-    public void testContainsValue() {
-        ConcurrentHashMap map = map5();
-        assertTrue(map.containsValue("A"));
-        assertFalse(map.containsValue("Z"));
-    }
-
-    /**
-     *   enumeration returns an enumeration containing the correct
-     *   elements
-     */
-    public void testEnumeration() {
-        ConcurrentHashMap map = map5();
-        Enumeration e = map.elements();
-        int count = 0;
-        while (e.hasMoreElements()) {
-            count++;
-            e.nextElement();
-        }
-        assertEquals(5, count);
-    }
-
-    /**
-     *  get returns the correct element at the given key,
-     *  or null if not present
-     */
-    public void testGet() {
-        ConcurrentHashMap map = map5();
-        assertEquals("A", (String)map.get(one));
-        ConcurrentHashMap empty = new ConcurrentHashMap();
-        assertNull(map.get("anything"));
-    }
-
-    /**
-     *  isEmpty is true of empty map and false for non-empty
-     */
-    public void testIsEmpty() {
-        ConcurrentHashMap empty = new ConcurrentHashMap();
-        ConcurrentHashMap map = map5();
-        assertTrue(empty.isEmpty());
-        assertFalse(map.isEmpty());
-    }
-
-    /**
-     *   keys returns an enumeration containing all the keys from the map
-     */
-    public void testKeys() {
-        ConcurrentHashMap map = map5();
-        Enumeration e = map.keys();
-        int count = 0;
-        while (e.hasMoreElements()) {
-            count++;
-            e.nextElement();
-        }
-        assertEquals(5, count);
-    }
-
-    /**
-     *   keySet returns a Set containing all the keys
-     */
-    public void testKeySet() {
-        ConcurrentHashMap 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.toArray returns contains all keys
-     */
-    public void testKeySetToArray() {
-        ConcurrentHashMap 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)));
-    }
-
-    /**
-     *  Values.toArray contains all values
-     */
-    public void testValuesToArray() {
-        ConcurrentHashMap 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.toArray contains all entries
-     */
-    public void testEntrySetToArray() {
-        ConcurrentHashMap 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()));
-        }
-    }
-
-    /**
-     * values collection contains all values
-     */
-    public void testValues() {
-        ConcurrentHashMap 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() {
-        ConcurrentHashMap 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() {
-        ConcurrentHashMap empty = new ConcurrentHashMap();
-        ConcurrentHashMap 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() {
-        ConcurrentHashMap 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() {
-        ConcurrentHashMap map = map5();
-        assertEquals("A", map.putIfAbsent(one, "Z"));
-    }
-
-    /**
-     *   replace fails when the given key is not present
-     */
-    public void testReplace() {
-        ConcurrentHashMap map = map5();
-        assertNull(map.replace(six, "Z"));
-        assertFalse(map.containsKey(six));
-    }
-
-    /**
-     *   replace succeeds if the key is already present
-     */
-    public void testReplace2() {
-        ConcurrentHashMap 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() {
-        ConcurrentHashMap 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() {
-        ConcurrentHashMap 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() {
-        ConcurrentHashMap map = map5();
-        map.remove(five);
-        assertEquals(4, map.size());
-        assertFalse(map.containsKey(five));
-    }
-
-    /**
-     * remove(key,value) removes only if pair present
-     */
-    public void testRemove2() {
-        ConcurrentHashMap map = map5();
-        map.remove(five, "E");
-        assertEquals(4, map.size());
-        assertFalse(map.containsKey(five));
-        map.remove(four, "A");
-        assertEquals(4, map.size());
-        assertTrue(map.containsKey(four));
-    }
-
-    /**
-     *   size returns the correct values
-     */
-    public void testSize() {
-        ConcurrentHashMap map = map5();
-        ConcurrentHashMap empty = new ConcurrentHashMap();
-        assertEquals(0, empty.size());
-        assertEquals(5, map.size());
-    }
-
-    /**
-     * toString contains toString of elements
-     */
-    public void testToString() {
-        ConcurrentHashMap map = map5();
-        String s = map.toString();
-        for (int i = 1; i <= 5; ++i) {
-            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
-        }
-    }
-
-    // Exception tests
-
-    /**
-     * Cannot create with negative capacity
-     */
-    public void testConstructor1() {
-        try {
-            new ConcurrentHashMap(-1,0,1);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * Cannot create with negative concurrency level
-     */
-    public void testConstructor2() {
-        try {
-            new ConcurrentHashMap(1,0,-1);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * Cannot create with only negative capacity
-     */
-    public void testConstructor3() {
-        try {
-            new ConcurrentHashMap(-1);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * get(null) throws NPE
-     */
-    public void testGet_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.get(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * containsKey(null) throws NPE
-     */
-    public void testContainsKey_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.containsKey(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * containsValue(null) throws NPE
-     */
-    public void testContainsValue_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.containsValue(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * contains(null) throws NPE
-     */
-    public void testContains_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.contains(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * put(null,x) throws NPE
-     */
-    public void testPut1_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.put(null, "whatever");
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * put(x, null) throws NPE
-     */
-    public void testPut2_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.put("whatever", null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * putIfAbsent(null, x) throws NPE
-     */
-    public void testPutIfAbsent1_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.putIfAbsent(null, "whatever");
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * replace(null, x) throws NPE
-     */
-    public void testReplace_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.replace(null, "whatever");
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * replace(null, x, y) throws NPE
-     */
-    public void testReplaceValue_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.replace(null, one, "whatever");
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * putIfAbsent(x, null) throws NPE
-     */
-    public void testPutIfAbsent2_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.putIfAbsent("whatever", null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * replace(x, null) throws NPE
-     */
-    public void testReplace2_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.replace("whatever", null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * replace(x, null, y) throws NPE
-     */
-    public void testReplaceValue2_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.replace("whatever", null, "A");
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * replace(x, y, null) throws NPE
-     */
-    public void testReplaceValue3_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.replace("whatever", one, null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * remove(null) throws NPE
-     */
-    public void testRemove1_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.put("sadsdf", "asdads");
-            c.remove(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * remove(null, x) throws NPE
-     */
-    public void testRemove2_NullPointerException() {
-        try {
-            ConcurrentHashMap c = new ConcurrentHashMap(5);
-            c.put("sadsdf", "asdads");
-            c.remove(null, "whatever");
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * remove(x, null) returns false
-     */
-    public void testRemove3() {
-        ConcurrentHashMap c = new ConcurrentHashMap(5);
-        c.put("sadsdf", "asdads");
-        assertFalse(c.remove("sadsdf", null));
-    }
-
-    /**
-     * A deserialized map equals original
-     */
-    public void testSerialization() throws Exception {
-        ConcurrentHashMap 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));
-        ConcurrentHashMap r = (ConcurrentHashMap)in.readObject();
-        assertEquals(q.size(), r.size());
-        assertTrue(q.equals(r));
-        assertTrue(r.equals(q));
-    }
-
-
-    /**
-     * SetValue of an EntrySet entry sets value in the map.
-     */
-    public void testSetValueWriteThrough() {
-        // 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
-        // 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
deleted file mode 100755
index 1fbc729..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentLinkedQueueTest.java
+++ /dev/null
@@ -1,507 +0,0 @@
-/*
- * 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 java.io.*;
-
-public class ConcurrentLinkedQueueTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(ConcurrentLinkedQueueTest.class);
-    }
-
-    /**
-     * Create a queue of given size containing consecutive
-     * Integers 0 ... n.
-     */
-    private ConcurrentLinkedQueue populatedQueue(int n) {
-        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-        assertTrue(q.isEmpty());
-        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
-     */
-    public void testConstructor1() {
-        assertEquals(0, new ConcurrentLinkedQueue().size());
-    }
-
-    /**
-     *  Initializing from null Collection throws NPE
-     */
-    public void testConstructor3() {
-        try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Initializing from Collection of null elements throws NPE
-     */
-    public void testConstructor4() {
-        try {
-            Integer[] ints = new Integer[SIZE];
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(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);
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
-            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);
-        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
-        for (int i = 0; i < SIZE; ++i)
-            assertEquals(ints[i], q.poll());
-    }
-
-    /**
-     * isEmpty is true before add, false after
-     */
-    public void testEmpty() {
-        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-        assertTrue(q.isEmpty());
-        q.add(one);
-        assertFalse(q.isEmpty());
-        q.add(two);
-        q.remove();
-        q.remove();
-        assertTrue(q.isEmpty());
-    }
-
-    /**
-     * size changes when elements added and removed
-     */
-    public void testSize() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(SIZE-i, q.size());
-            q.remove();
-        }
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.size());
-            q.add(new Integer(i));
-        }
-    }
-
-    /**
-     * offer(null) throws NPE
-     */
-    public void testOfferNull() {
-        try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-            q.offer(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * add(null) throws NPE
-     */
-    public void testAddNull() {
-        try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-            q.add(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * Offer returns true
-     */
-    public void testOffer() {
-        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-        assertTrue(q.offer(zero));
-        assertTrue(q.offer(one));
-    }
-
-    /**
-     * add returns true
-     */
-    public void testAdd() {
-        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-        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 {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-            q.addAll(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * addAll(this) throws IAE
-     */
-    public void testAddAllSelf() {
-        try {
-            ConcurrentLinkedQueue q = populatedQueue(SIZE);
-            q.addAll(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * addAll of a collection with null elements throws NPE
-     */
-    public void testAddAll2() {
-        try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-            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 {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-            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) {}
-    }
-
-    /**
-     * 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);
-        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());
-    }
-
-    /**
-     * poll succeeds unless empty
-     */
-    public void testPoll() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.poll());
-        }
-        assertNull(q.poll());
-    }
-
-    /**
-     * peek returns next element, or null if empty
-     */
-    public void testPeek() {
-        ConcurrentLinkedQueue q = populatedQueue(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());
-    }
-
-    /**
-     * element returns next element, or throws NSEE if empty
-     */
-    public void testElement() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.element());
-            assertEquals(i, q.poll());
-        }
-        try {
-            q.element();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     *  remove removes next element, or throws NSEE if empty
-     */
-    public void testRemove() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.remove());
-        }
-        try {
-            q.remove();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove(x) removes x and returns true if present
-     */
-    public void testRemoveElement() {
-        ConcurrentLinkedQueue q = populatedQueue(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() {
-        ConcurrentLinkedQueue q = populatedQueue(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() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        q.clear();
-        assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
-        q.add(one);
-        assertFalse(q.isEmpty());
-        q.clear();
-        assertTrue(q.isEmpty());
-    }
-
-    /**
-     * containsAll(c) is true when c contains a subset of elements
-     */
-    public void testContainsAll() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        ConcurrentLinkedQueue p = new ConcurrentLinkedQueue();
-        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 change
-     */
-    public void testRetainAll() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        ConcurrentLinkedQueue p = populatedQueue(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) {
-            ConcurrentLinkedQueue q = populatedQueue(SIZE);
-            ConcurrentLinkedQueue p = populatedQueue(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() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        Arrays.sort(o);
-        for (int i = 0; i < o.length; i++)
-            assertEquals(o[i], q.poll());
-    }
-
-    /**
-     *  toArray(a) contains all elements
-     */
-    public void testToArray2() {
-        ConcurrentLinkedQueue q = populatedQueue(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.poll());
-    }
-
-    /**
-     * toArray(null) throws NPE
-     */
-    public void testToArray_BadArg() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        try {
-            Object o[] = q.toArray(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * toArray with incompatible array type throws ArrayStoreException
-     */
-    public void testToArray1_BadArg() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        try {
-            Object o[] = q.toArray(new String[10]);
-            shouldThrow();
-        } catch (ArrayStoreException success) {}
-    }
-
-    /**
-     *  iterator iterates through all elements
-     */
-    public void testIterator() {
-        ConcurrentLinkedQueue q = populatedQueue(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 ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-        q.add(one);
-        q.add(two);
-        q.add(three);
-
-        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 ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-        q.add(one);
-        q.add(two);
-        q.add(three);
-
-        for (Iterator it = q.iterator(); it.hasNext();) {
-            q.remove();
-            it.next();
-        }
-
-        assertEquals("queue should be empty again", 0, q.size());
-    }
-
-    /**
-     * iterator.remove removes current element
-     */
-    public void testIteratorRemove () {
-        final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-        q.add(one);
-        q.add(two);
-        q.add(three);
-        Iterator it = q.iterator();
-        it.next();
-        it.remove();
-        it = q.iterator();
-        assertSame(it.next(), two);
-        assertSame(it.next(), three);
-        assertFalse(it.hasNext());
-    }
-
-
-    /**
-     * toString contains toStrings of elements
-     */
-    public void testToString() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        String s = q.toString();
-        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() throws Exception {
-        ConcurrentLinkedQueue q = populatedQueue(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));
-        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
deleted file mode 100644
index 3cf5b75..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListMapTest.java
+++ /dev/null
@@ -1,1280 +0,0 @@
-/*
- * 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
deleted file mode 100644
index 2d03b3c..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSetTest.java
+++ /dev/null
@@ -1,961 +0,0 @@
-/*
- * 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
deleted file mode 100644
index fc70935..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSubMapTest.java
+++ /dev/null
@@ -1,1438 +0,0 @@
-/*
- * 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
deleted file mode 100644
index 9f0a496..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ConcurrentSkipListSubSetTest.java
+++ /dev/null
@@ -1,1117 +0,0 @@
-/*
- * 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
deleted file mode 100755
index 90d708a..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/CopyOnWriteArrayListTest.java
+++ /dev/null
@@ -1,611 +0,0 @@
-/*
- * 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 java.io.*;
-
-public class CopyOnWriteArrayListTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(CopyOnWriteArrayListTest.class);
-    }
-
-    static CopyOnWriteArrayList populatedArray(int n) {
-        CopyOnWriteArrayList a = new CopyOnWriteArrayList();
-        assertTrue(a.isEmpty());
-        for (int i = 0; i < n; ++i)
-            a.add(new Integer(i));
-        assertFalse(a.isEmpty());
-        assertEquals(n, a.size());
-        return a;
-    }
-
-
-    /**
-     * a new list is empty
-     */
-    public void testConstructor() {
-        CopyOnWriteArrayList a = new CopyOnWriteArrayList();
-        assertTrue(a.isEmpty());
-    }
-
-    /**
-     * new list contains all elements of initializing array
-     */
-    public void testConstructor2() {
-        Integer[] ints = new Integer[SIZE];
-        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)
-            assertEquals(ints[i], a.get(i));
-    }
-
-    /**
-     * new list contains all elements of initializing collection
-     */
-    public void testConstructor3() {
-        Integer[] ints = new Integer[SIZE];
-        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)
-            assertEquals(ints[i], a.get(i));
-    }
-
-
-    /**
-     *   addAll  adds each element from the given collection
-     */
-    public void testAddAll() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        Vector v = new Vector();
-        v.add(three);
-        v.add(four);
-        v.add(five);
-        full.addAll(v);
-        assertEquals(6, full.size());
-    }
-
-    /**
-     *   addAllAbsent adds each element from the given collection that did not
-     *  already exist in the List
-     */
-    public void testAddAllAbsent() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        Vector v = new Vector();
-        v.add(three);
-        v.add(four);
-        v.add(one); // will not add this element
-        full.addAllAbsent(v);
-        assertEquals(5, full.size());
-    }
-
-    /**
-     *   addIfAbsent will not add the element if it already exists in the list
-     */
-    public void testAddIfAbsent() {
-        CopyOnWriteArrayList full = populatedArray(SIZE);
-        full.addIfAbsent(one);
-        assertEquals(SIZE, full.size());
-    }
-
-    /**
-     *   addIfAbsent adds the element when it does not exist in the list
-     */
-    public void testAddIfAbsent2() {
-        CopyOnWriteArrayList full = populatedArray(SIZE);
-        full.addIfAbsent(three);
-        assertTrue(full.contains(three));
-    }
-
-    /**
-     *   clear removes all elements from the list
-     */
-    public void testClear() {
-        CopyOnWriteArrayList full = populatedArray(SIZE);
-        full.clear();
-        assertEquals(0, full.size());
-    }
-
-
-    /**
-     *  Cloned list is equal
-     */
-    public void testClone() {
-        CopyOnWriteArrayList l1 = populatedArray(SIZE);
-        CopyOnWriteArrayList l2 = (CopyOnWriteArrayList)(l1.clone());
-        assertEquals(l1, l2);
-        l1.clear();
-        assertFalse(l1.equals(l2));
-    }
-
-    /**
-     *   contains is true for added elements
-     */
-    public void testContains() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        assertTrue(full.contains(one));
-        assertFalse(full.contains(five));
-    }
-
-    /**
-     * adding at an index places it in the indicated index
-     */
-    public void testAddIndex() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        full.add(0, m1);
-        assertEquals(4, full.size());
-        assertEquals(m1, full.get(0));
-        assertEquals(zero, full.get(1));
-
-        full.add(2, m2);
-        assertEquals(5, full.size());
-        assertEquals(m2, full.get(2));
-        assertEquals(two, full.get(4));
-    }
-
-    /**
-     * lists with same elements are equal and have same hashCode
-     */
-    public void testEquals() {
-        CopyOnWriteArrayList a = populatedArray(3);
-        CopyOnWriteArrayList b = populatedArray(3);
-        assertTrue(a.equals(b));
-        assertTrue(b.equals(a));
-        assertEquals(a.hashCode(), b.hashCode());
-        a.add(m1);
-        assertFalse(a.equals(b));
-        assertFalse(b.equals(a));
-        b.add(m1);
-        assertTrue(a.equals(b));
-        assertTrue(b.equals(a));
-        assertEquals(a.hashCode(), b.hashCode());
-    }
-
-
-    /**
-     *   containsAll returns true for collection with subset of elements
-     */
-    public void testContainsAll() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        Vector v = new Vector();
-        v.add(one);
-        v.add(two);
-        assertTrue(full.containsAll(v));
-        v.add(six);
-        assertFalse(full.containsAll(v));
-    }
-
-    /**
-     *   get returns the value at the given index
-     */
-    public void testGet() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        assertEquals(0, full.get(0));
-    }
-
-    /**
-     *   indexOf gives the index for the given object
-     */
-    public void testIndexOf() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        assertEquals(1, full.indexOf(one));
-        assertEquals(-1, full.indexOf("puppies"));
-    }
-
-    /**
-     *   indexOf gives the index based on the given index
-     *  at which to start searching
-     */
-    public void testIndexOf2() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        assertEquals(1, full.indexOf(one, 0));
-        assertEquals(-1, full.indexOf(one, 2));
-    }
-
-    /**
-     *   isEmpty returns true when empty, else false
-     */
-    public void testIsEmpty() {
-        CopyOnWriteArrayList empty = new CopyOnWriteArrayList();
-        CopyOnWriteArrayList full = populatedArray(SIZE);
-        assertTrue(empty.isEmpty());
-        assertFalse(full.isEmpty());
-    }
-
-    /**
-     *   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, i.next());
-        assertEquals(SIZE, j);
-    }
-
-    /**
-     * iterator.remove throws UnsupportedOperationException
-     */
-    public void testIteratorRemove () {
-        CopyOnWriteArrayList full = populatedArray(SIZE);
-        Iterator it = full.iterator();
-        it.next();
-        try {
-            it.remove();
-            shouldThrow();
-        } catch (UnsupportedOperationException success) {}
-    }
-
-    /**
-     * toString contains toString of elements
-     */
-    public void testToString() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        String s = full.toString();
-        for (int i = 0; i < 3; ++i) {
-            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
-        }
-    }
-
-    /**
-     *   lastIndexOf returns the index for the given object
-     */
-    public void testLastIndexOf1() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        full.add(one);
-        full.add(three);
-        assertEquals(3, full.lastIndexOf(one));
-        assertEquals(-1, full.lastIndexOf(six));
-    }
-
-    /**
-     *   lastIndexOf returns the index from the given starting point
-     */
-    public void testlastIndexOf2() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        full.add(one);
-        full.add(three);
-        assertEquals(3, full.lastIndexOf(one, 4));
-        assertEquals(-1, full.lastIndexOf(three, 3));
-    }
-
-    /**
-     *  listIterator traverses all elements
-     */
-    public void testListIterator1() {
-        CopyOnWriteArrayList full = populatedArray(SIZE);
-        ListIterator i = full.listIterator();
-        int j;
-        for (j = 0; i.hasNext(); j++)
-            assertEquals(j, i.next());
-        assertEquals(SIZE, j);
-    }
-
-    /**
-     *  listIterator only returns those elements after the given index
-     */
-    public void testListIterator2() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        ListIterator i = full.listIterator(1);
-        int j;
-        for (j = 0; i.hasNext(); j++)
-            assertEquals(j+1, i.next());
-        assertEquals(2, j);
-    }
-
-    /**
-     *   remove  removes and returns the object at the given index
-     */
-    public void testRemove() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        assertEquals(2, full.remove(2));
-        assertEquals(2, full.size());
-    }
-
-    /**
-     *   removeAll  removes all elements from the given collection
-     */
-    public void testRemoveAll() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        Vector v = new Vector();
-        v.add(one);
-        v.add(two);
-        full.removeAll(v);
-        assertEquals(1, full.size());
-    }
-
-    /**
-     *   set  changes the element at the given index
-     */
-    public void testSet() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        assertEquals(2, full.set(2, four));
-        assertEquals(4, full.get(2));
-    }
-
-    /**
-     *   size returns the number of elements
-     */
-    public void testSize() {
-        CopyOnWriteArrayList empty = new CopyOnWriteArrayList();
-        CopyOnWriteArrayList full = populatedArray(SIZE);
-        assertEquals(SIZE, full.size());
-        assertEquals(0, empty.size());
-    }
-
-    /**
-     *   toArray returns an Object array containing all elements from the list
-     */
-    public void testToArray() {
-        CopyOnWriteArrayList full = populatedArray(3);
-        Object[] o = full.toArray();
-        assertEquals(3, o.length);
-        assertEquals(0, o[0]);
-        assertEquals(1, o[1]);
-        assertEquals(2, o[2]);
-    }
-
-    /**
-     *   toArray returns an Integer array containing all elements from
-     *   the list
-     */
-    public void testToArray2() {
-        CopyOnWriteArrayList full = populatedArray(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());
-    }
-
-
-    /**
-     * sublists contains elements at indexes offset from their base
-     */
-    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) {
-                List b = a.subList(j,i);
-                for (int k = j; k < i; ++k) {
-                    assertEquals(new Integer(k), b.get(k-j));
-                }
-            }
-        }
-
-        List s = a.subList(2, 5);
-        assertEquals(s.size(), 3);
-        s.set(2, m1);
-        assertEquals(a.get(4), m1);
-        s.clear();
-        assertEquals(a.size(), 7);
-    }
-
-    // Exception tests
-
-    /**
-     *   toArray throws an ArrayStoreException when the given array
-     *  can not store the objects inside the list
-     */
-    public void testToArray_ArrayStoreException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.add("zfasdfsdf");
-            c.add("asdadasd");
-            c.toArray(new Long[5]);
-            shouldThrow();
-        } catch (ArrayStoreException success) {}
-    }
-
-    /**
-     *   get throws an IndexOutOfBoundsException on a negative index
-     */
-    public void testGet1_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.get(-1);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   get throws an IndexOutOfBoundsException on a too high index
-     */
-    public void testGet2_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.add("asdasd");
-            c.add("asdad");
-            c.get(100);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   set throws an IndexOutOfBoundsException on a negative index
-     */
-    public void testSet1_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.set(-1,"qwerty");
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   set throws an IndexOutOfBoundsException on a too high index
-     */
-    public void testSet2() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.add("asdasd");
-            c.add("asdad");
-            c.set(100, "qwerty");
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   add throws an IndexOutOfBoundsException on a negative index
-     */
-    public void testAdd1_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.add(-1,"qwerty");
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   add throws an IndexOutOfBoundsException on a too high index
-     */
-    public void testAdd2_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.add("asdasd");
-            c.add("asdasdasd");
-            c.add(100, "qwerty");
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   remove throws an IndexOutOfBoundsException on a negative index
-     */
-    public void testRemove1_IndexOutOfBounds() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.remove(-1);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   remove throws an IndexOutOfBoundsException on a too high index
-     */
-    public void testRemove2_IndexOutOfBounds() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.add("asdasd");
-            c.add("adasdasd");
-            c.remove(100);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   addAll throws an IndexOutOfBoundsException on a negative index
-     */
-    public void testAddAll1_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.addAll(-1,new LinkedList());
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   addAll throws an IndexOutOfBoundsException on a too high index
-     */
-    public void testAddAll2_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.add("asdasd");
-            c.add("asdasdasd");
-            c.addAll(100, new LinkedList());
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   listIterator throws an IndexOutOfBoundsException on a negative index
-     */
-    public void testListIterator1_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.listIterator(-1);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   listIterator throws an IndexOutOfBoundsException on a too high index
-     */
-    public void testListIterator2_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.add("adasd");
-            c.add("asdasdas");
-            c.listIterator(100);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   subList throws an IndexOutOfBoundsException on a negative index
-     */
-    public void testSubList1_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.subList(-1,100);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   subList throws an IndexOutOfBoundsException on a too high index
-     */
-    public void testSubList2_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.add("asdasd");
-            c.subList(1,100);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     *   subList throws IndexOutOfBoundsException when the second index
-     *  is lower then the first
-     */
-    public void testSubList3_IndexOutOfBoundsException() {
-        try {
-            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
-            c.subList(3,1);
-            shouldThrow();
-        } catch (IndexOutOfBoundsException success) {}
-    }
-
-    /**
-     * a deserialized serialized list is equal
-     */
-    public void testSerialization() throws Exception {
-        CopyOnWriteArrayList q = populatedArray(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));
-        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
deleted file mode 100755
index c78ac50..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/CopyOnWriteArraySetTest.java
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * 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 java.io.*;
-
-public class CopyOnWriteArraySetTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(CopyOnWriteArraySetTest.class);
-    }
-
-    static CopyOnWriteArraySet populatedSet(int n) {
-        CopyOnWriteArraySet a = new CopyOnWriteArraySet();
-        assertTrue(a.isEmpty());
-        for (int i = 0; i < n; ++i)
-            a.add(new Integer(i));
-        assertFalse(a.isEmpty());
-        assertEquals(n, a.size());
-        return a;
-    }
-
-    /**
-     * Default-constructed set is empty
-     */
-    public void testConstructor() {
-        CopyOnWriteArraySet a = new CopyOnWriteArraySet();
-        assertTrue(a.isEmpty());
-    }
-
-    /**
-     * Collection-constructed set holds all of its elements
-     */
-    public void testConstructor3() {
-        Integer[] ints = new Integer[SIZE];
-        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)
-            assertTrue(a.contains(ints[i]));
-    }
-
-
-    /**
-     *  addAll adds each element from the given collection
-     */
-    public void testAddAll() {
-        CopyOnWriteArraySet full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(three);
-        v.add(four);
-        v.add(five);
-        full.addAll(v);
-        assertEquals(6, full.size());
-    }
-
-    /**
-     *  addAll adds each element from the given collection that did not
-     *  already exist in the set
-     */
-    public void testAddAll2() {
-        CopyOnWriteArraySet full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(three);
-        v.add(four);
-        v.add(one); // will not add this element
-        full.addAll(v);
-        assertEquals(5, full.size());
-    }
-
-    /**
-     *  add will not add the element if it already exists in the set
-     */
-    public void testAdd2() {
-        CopyOnWriteArraySet full = populatedSet(3);
-        full.add(one);
-        assertEquals(3, full.size());
-    }
-
-    /**
-     *  add  adds the element when it does not exist
-     *  in the set
-     */
-    public void testAdd3() {
-        CopyOnWriteArraySet full = populatedSet(3);
-        full.add(three);
-        assertTrue(full.contains(three));
-    }
-
-    /**
-     *  clear removes all elements from the set
-     */
-    public void testClear() {
-        CopyOnWriteArraySet full = populatedSet(3);
-        full.clear();
-        assertEquals(0, full.size());
-    }
-
-    /**
-     *   contains returns true for added elements
-     */
-    public void testContains() {
-        CopyOnWriteArraySet full = populatedSet(3);
-        assertTrue(full.contains(one));
-        assertFalse(full.contains(five));
-    }
-
-    /**
-     * Sets with equal elements are equal
-     */
-    public void testEquals() {
-        CopyOnWriteArraySet a = populatedSet(3);
-        CopyOnWriteArraySet b = populatedSet(3);
-        assertTrue(a.equals(b));
-        assertTrue(b.equals(a));
-        assertEquals(a.hashCode(), b.hashCode());
-        a.add(m1);
-        assertFalse(a.equals(b));
-        assertFalse(b.equals(a));
-        b.add(m1);
-        assertTrue(a.equals(b));
-        assertTrue(b.equals(a));
-        assertEquals(a.hashCode(), b.hashCode());
-    }
-
-
-    /**
-     *  containsAll returns true for collections with subset of elements
-     */
-    public void testContainsAll() {
-        CopyOnWriteArraySet full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(one);
-        v.add(two);
-        assertTrue(full.containsAll(v));
-        v.add(six);
-        assertFalse(full.containsAll(v));
-    }
-
-    /**
-     *  isEmpty is true when empty, else false
-     */
-    public void testIsEmpty() {
-        CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
-        CopyOnWriteArraySet full = populatedSet(3);
-        assertTrue(empty.isEmpty());
-        assertFalse(full.isEmpty());
-    }
-
-    /**
-     *  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, i.next());
-        assertEquals(3, j);
-    }
-
-    /**
-     * iterator remove is unsupported
-     */
-    public void testIteratorRemove () {
-        CopyOnWriteArraySet full = populatedSet(3);
-        Iterator it = full.iterator();
-        it.next();
-        try {
-            it.remove();
-            shouldThrow();
-        } catch (UnsupportedOperationException success) {}
-    }
-
-    /**
-     * toString holds toString of elements
-     */
-    public void testToString() {
-        CopyOnWriteArraySet full = populatedSet(3);
-        String s = full.toString();
-        for (int i = 0; i < 3; ++i) {
-            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
-        }
-    }
-
-
-    /**
-     *  removeAll  removes all elements from the given collection
-     */
-    public void testRemoveAll() {
-        CopyOnWriteArraySet full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(one);
-        v.add(two);
-        full.removeAll(v);
-        assertEquals(1, full.size());
-    }
-
-
-    /**
-     * remove removes an element
-     */
-    public void testRemove() {
-        CopyOnWriteArraySet full = populatedSet(3);
-        full.remove(one);
-        assertFalse(full.contains(one));
-        assertEquals(2, full.size());
-    }
-
-    /**
-     *  size returns the number of elements
-     */
-    public void testSize() {
-        CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
-        CopyOnWriteArraySet full = populatedSet(3);
-        assertEquals(3, full.size());
-        assertEquals(0, empty.size());
-    }
-
-    /**
-     *  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, o[0]);
-        assertEquals(1, o[1]);
-        assertEquals(2, o[2]);
-    }
-
-    /**
-     *  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, (int) i[0]);
-        assertEquals(1, (int) i[1]);
-        assertEquals(2, (int) i[2]);
-    }
-
-
-    /**
-     *  toArray throws an ArrayStoreException when the given array can
-     *  not store the objects inside the set
-     */
-    public void testToArray_ArrayStoreException() {
-        try {
-            CopyOnWriteArraySet c = new CopyOnWriteArraySet();
-            c.add("zfasdfsdf");
-            c.add("asdadasd");
-            c.toArray(new Long[5]);
-            shouldThrow();
-        } catch (ArrayStoreException success) {}
-    }
-
-    /**
-     * A deserialized serialized set is equal
-     */
-    public void testSerialization() throws Exception {
-        CopyOnWriteArraySet 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));
-        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
deleted file mode 100755
index b06004e..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/CountDownLatchTest.java
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * 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;
-
-public class CountDownLatchTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(CountDownLatchTest.class);
-    }
-
-    /**
-     * negative constructor argument throws IAE
-     */
-    public void testConstructor() {
-        try {
-            new CountDownLatch(-1);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * getCount returns initial count and decreases after countDown
-     */
-    public void testGetCount() {
-        final CountDownLatch l = new CountDownLatch(2);
-        assertEquals(2, l.getCount());
-        l.countDown();
-        assertEquals(1, l.getCount());
-    }
-
-    /**
-     * countDown decrements count when positive and has no effect when zero
-     */
-    public void testCountDown() {
-        final CountDownLatch l = new CountDownLatch(1);
-        assertEquals(1, l.getCount());
-        l.countDown();
-        assertEquals(0, l.getCount());
-        l.countDown();
-        assertEquals(0, l.getCount());
-    }
-
-    /**
-     * await returns after countDown to zero, but not before
-     */
-    public void testAwait() throws InterruptedException {
-        final CountDownLatch l = new CountDownLatch(2);
-
-        Thread t = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                threadAssertTrue(l.getCount() > 0);
-                l.await();
-                threadAssertTrue(l.getCount() == 0);
-            }});
-
-        t.start();
-        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() throws InterruptedException {
-        final CountDownLatch l = new CountDownLatch(2);
-
-        Thread t = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                threadAssertTrue(l.getCount() > 0);
-                threadAssertTrue(l.await(SMALL_DELAY_MS, MILLISECONDS));
-            }});
-
-        t.start();
-        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() throws InterruptedException {
-        final CountDownLatch l = new CountDownLatch(1);
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                threadAssertTrue(l.getCount() > 0);
-                l.await();
-            }});
-
-        t.start();
-        assertEquals(l.getCount(), 1);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     * timed await throws IE if interrupted before counted down
-     */
-    public void testTimedAwait_InterruptedException() throws InterruptedException {
-        final CountDownLatch l = new CountDownLatch(1);
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                threadAssertTrue(l.getCount() > 0);
-                l.await(MEDIUM_DELAY_MS, MILLISECONDS);
-            }});
-
-        t.start();
-        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() throws InterruptedException {
-        final CountDownLatch l = new CountDownLatch(1);
-        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();
-        assertEquals(l.getCount(), 1);
-        t.join();
-    }
-
-    /**
-     * toString indicates current count
-     */
-    public void testToString() {
-        CountDownLatch s = new CountDownLatch(2);
-        String us = s.toString();
-        assertTrue(us.indexOf("Count = 2") >= 0);
-        s.countDown();
-        String s1 = s.toString();
-        assertTrue(s1.indexOf("Count = 1") >= 0);
-        s.countDown();
-        String s2 = s.toString();
-        assertTrue(s2.indexOf("Count = 0") >= 0);
-    }
-
-}
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
deleted file mode 100755
index b8f8b24..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/CyclicBarrierTest.java
+++ /dev/null
@@ -1,425 +0,0 @@
-/*
- * 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 java.util.concurrent.locks.*;
-import java.util.concurrent.atomic.*;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-
-public class CyclicBarrierTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(CyclicBarrierTest.class);
-    }
-
-    private volatile int countAction;
-    private class MyAction implements Runnable {
-        public void run() { ++countAction; }
-    }
-
-    /**
-     * Creating with negative parties throws IAE
-     */
-    public void testConstructor1() {
-        try {
-            new CyclicBarrier(-1, (Runnable)null);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * Creating with negative parties and no action throws IAE
-     */
-    public void testConstructor2() {
-        try {
-            new CyclicBarrier(-1);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * getParties returns the number of parties given in constructor
-     */
-    public void testGetParties() {
-        CyclicBarrier b = new CyclicBarrier(2);
-        assertEquals(2, b.getParties());
-        assertEquals(0, b.getNumberWaiting());
-    }
-
-    /**
-     * A 1-party barrier triggers after single await
-     */
-    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() 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() throws Exception {
-        final CyclicBarrier b = new CyclicBarrier(2);
-        Thread t = new Thread(new CheckedRunnable() {
-            public void realRun() throws Exception {
-                b.await();
-                b.await();
-                b.await();
-                b.await();
-            }});
-
-        t.start();
-        b.await();
-        b.await();
-        b.await();
-        b.await();
-        t.join();
-    }
-
-
-    /**
-     * An interruption in one party causes others waiting in await to
-     * throw BrokenBarrierException
-     */
-    public void testAwait1_Interrupted_BrokenBarrier() throws Exception {
-        final CyclicBarrier c = new CyclicBarrier(3);
-        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() throws Exception {
-        final CyclicBarrier c = new CyclicBarrier(3);
-        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() throws InterruptedException {
-        final CyclicBarrier c = new CyclicBarrier(2);
-        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() throws InterruptedException {
-        final CyclicBarrier c = new CyclicBarrier(3);
-        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() throws InterruptedException {
-        final CyclicBarrier c = new CyclicBarrier(3);
-        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() throws InterruptedException {
-        final CyclicBarrier c = new CyclicBarrier(3);
-        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() throws Exception {
-        final CyclicBarrier c = new CyclicBarrier(3);
-        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() 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.interrupt();
-        t.join();
-    }
-
-    /**
-     * Reset of a non-broken barrier does not break barrier
-     */
-    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() 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() 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() 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
deleted file mode 100755
index 7aeceda..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/DelayQueueTest.java
+++ /dev/null
@@ -1,915 +0,0 @@
-/*
- * 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 static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.util.concurrent.*;
-
-public class DelayQueueTest extends JSR166TestCase {
-    public static Test suite() {
-        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
-     * (so, no blocking solely for delays) but are still ordered
-     */
-    static class PDelay implements Delayed {
-        int pseudodelay;
-        PDelay(int i) { pseudodelay = Integer.MIN_VALUE + i; }
-        public int compareTo(PDelay y) {
-            int i = pseudodelay;
-            int j = y.pseudodelay;
-            if (i < j) return -1;
-            if (i > j) return 1;
-            return 0;
-        }
-
-        public int compareTo(Delayed y) {
-            return compareTo((PDelay)y);
-        }
-
-        public boolean equals(Object other) {
-            return equals((PDelay)other);
-        }
-        public boolean equals(PDelay other) {
-            return other.pseudodelay == pseudodelay;
-        }
-
-
-        public long getDelay(TimeUnit ignore) {
-            return pseudodelay;
-        }
-        public int intValue() {
-            return pseudodelay;
-        }
-
-        public String toString() {
-            return String.valueOf(pseudodelay);
-        }
-    }
-
-
-    /**
-     * Delayed implementation that actually delays
-     */
-    static class NanoDelay implements Delayed {
-        long trigger;
-        NanoDelay(long i) {
-            trigger = System.nanoTime() + i;
-        }
-        public int compareTo(NanoDelay y) {
-            long i = trigger;
-            long j = y.trigger;
-            if (i < j) return -1;
-            if (i > j) return 1;
-            return 0;
-        }
-
-        public int compareTo(Delayed y) {
-            return compareTo((NanoDelay)y);
-        }
-
-        public boolean equals(Object other) {
-            return equals((NanoDelay)other);
-        }
-        public boolean equals(NanoDelay other) {
-            return other.trigger == trigger;
-        }
-
-        public long getDelay(TimeUnit unit) {
-            long n = trigger - System.nanoTime();
-            return unit.convert(n, TimeUnit.NANOSECONDS);
-        }
-
-        public long getTriggerTime() {
-            return trigger;
-        }
-
-        public String toString() {
-            return String.valueOf(trigger);
-        }
-    }
-
-
-    /**
-     * Create a queue of given size containing consecutive
-     * PDelays 0 ... n.
-     */
-    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)));
-        assertFalse(q.isEmpty());
-        assertEquals(NOCAP, q.remainingCapacity());
-        assertEquals(n, q.size());
-        return q;
-    }
-
-    /**
-     * A new queue has unbounded capacity
-     */
-    public void testConstructor1() {
-        assertEquals(NOCAP, new DelayQueue().remainingCapacity());
-    }
-
-    /**
-     * Initializing from null Collection throws NPE
-     */
-    public void testConstructor3() {
-        try {
-            DelayQueue q = new DelayQueue(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Initializing from Collection of null elements throws NPE
-     */
-    public void testConstructor4() {
-        try {
-            PDelay[] ints = new PDelay[SIZE];
-            DelayQueue q = new DelayQueue(Arrays.asList(ints));
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Initializing from Collection with some null elements throws NPE
-     */
-    public void testConstructor5() {
-        try {
-            PDelay[] ints = new PDelay[SIZE];
-            for (int i = 0; i < SIZE-1; ++i)
-                ints[i] = new PDelay(i);
-            DelayQueue q = new DelayQueue(Arrays.asList(ints));
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Queue contains all elements of collection used to initialize
-     */
-    public void testConstructor6() {
-        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());
-    }
-
-    /**
-     * isEmpty is true before add, false after
-     */
-    public void testEmpty() {
-        DelayQueue q = new DelayQueue();
-        assertTrue(q.isEmpty());
-        assertEquals(NOCAP, q.remainingCapacity());
-        q.add(new PDelay(1));
-        assertFalse(q.isEmpty());
-        q.add(new PDelay(2));
-        q.remove();
-        q.remove();
-        assertTrue(q.isEmpty());
-    }
-
-    /**
-     * remainingCapacity does not change when elements added or removed,
-     * but size does
-     */
-    public void testRemainingCapacity() {
-        DelayQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(NOCAP, q.remainingCapacity());
-            assertEquals(SIZE-i, q.size());
-            q.remove();
-        }
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(NOCAP, q.remainingCapacity());
-            assertEquals(i, q.size());
-            q.add(new PDelay(i));
-        }
-    }
-
-    /**
-     * offer(null) throws NPE
-     */
-    public void testOfferNull() {
-        try {
-            DelayQueue q = new DelayQueue();
-            q.offer(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * add(null) throws NPE
-     */
-    public void testAddNull() {
-        try {
-            DelayQueue q = new DelayQueue();
-            q.add(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * offer non-null succeeds
-     */
-    public void testOffer() {
-        DelayQueue q = new DelayQueue();
-        assertTrue(q.offer(new PDelay(0)));
-        assertTrue(q.offer(new PDelay(1)));
-    }
-
-    /**
-     * add succeeds
-     */
-    public void testAdd() {
-        DelayQueue q = new DelayQueue();
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.size());
-            assertTrue(q.add(new PDelay(i)));
-        }
-    }
-
-    /**
-     * addAll(null) throws NPE
-     */
-    public void testAddAll1() {
-        try {
-            DelayQueue q = new DelayQueue();
-            q.addAll(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * addAll(this) throws IAE
-     */
-    public void testAddAllSelf() {
-        try {
-            DelayQueue q = populatedQueue(SIZE);
-            q.addAll(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * addAll of a collection with null elements throws NPE
-     */
-    public void testAddAll2() {
-        try {
-            DelayQueue q = new DelayQueue();
-            PDelay[] ints = new PDelay[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 {
-            DelayQueue q = new DelayQueue();
-            PDelay[] ints = new PDelay[SIZE];
-            for (int i = 0; i < SIZE-1; ++i)
-                ints[i] = new PDelay(i);
-            q.addAll(Arrays.asList(ints));
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Queue contains all elements of successful addAll
-     */
-    public void testAddAll5() {
-        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 {
-            DelayQueue q = new DelayQueue();
-            q.put(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-     }
-
-    /**
-     * all elements successfully put are contained
-     */
-     public void testPut() {
-         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());
-    }
-
-    /**
-     * put doesn't block waiting for take
-     */
-    public void testPutWithTake() throws InterruptedException {
-        final DelayQueue q = new DelayQueue();
-        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() throws InterruptedException {
-        final DelayQueue q = new DelayQueue();
-        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));
-            }});
-
-        t.start();
-        Thread.sleep(SMALL_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     * take retrieves elements in priority order
-     */
-    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() throws InterruptedException {
-        final DelayQueue q = new DelayQueue();
-        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 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();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-
-    /**
-     * poll succeeds unless empty
-     */
-    public void testPoll() {
-        DelayQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(new PDelay(i), ((PDelay)q.poll()));
-        }
-        assertNull(q.poll());
-    }
-
-    /**
-     * timed pool with zero timeout succeeds when non-empty, else times out
-     */
-    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() 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() 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();
-        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 DelayQueue q = new DelayQueue();
-        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();
-    }
-
-
-    /**
-     * peek returns next element, or null if empty
-     */
-    public void testPeek() {
-        DelayQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(new PDelay(i), ((PDelay)q.peek()));
-            assertEquals(new PDelay(i), ((PDelay)q.poll()));
-            if (q.isEmpty())
-                assertNull(q.peek());
-            else
-                assertFalse(new PDelay(i).equals(q.peek()));
-        }
-        assertNull(q.peek());
-    }
-
-    /**
-     * element returns next element, or throws NSEE if empty
-     */
-    public void testElement() {
-        DelayQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(new PDelay(i), ((PDelay)q.element()));
-            q.poll();
-        }
-        try {
-            q.element();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove removes next element, or throws NSEE if empty
-     */
-    public void testRemove() {
-        DelayQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(new PDelay(i), ((PDelay)q.remove()));
-        }
-        try {
-            q.remove();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove(x) removes x and returns true if present
-     */
-    public void testRemoveElement() {
-        DelayQueue q = populatedQueue(SIZE);
-        for (int i = 1; i < SIZE; i+=2) {
-            assertTrue(q.remove(new PDelay(i)));
-        }
-        for (int i = 0; i < SIZE; i+=2) {
-            assertTrue(q.remove(new PDelay(i)));
-            assertFalse(q.remove(new PDelay(i+1)));
-        }
-        assertTrue(q.isEmpty());
-    }
-
-    /**
-     * contains(x) reports true when elements added but not yet removed
-     */
-    public void testContains() {
-        DelayQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertTrue(q.contains(new PDelay(i)));
-            q.poll();
-            assertFalse(q.contains(new PDelay(i)));
-        }
-    }
-
-    /**
-     * clear removes all elements
-     */
-    public void testClear() {
-        DelayQueue q = populatedQueue(SIZE);
-        q.clear();
-        assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
-        assertEquals(NOCAP, q.remainingCapacity());
-        PDelay x = new PDelay(1);
-        q.add(x);
-        assertFalse(q.isEmpty());
-        assertTrue(q.contains(x));
-        q.clear();
-        assertTrue(q.isEmpty());
-    }
-
-    /**
-     * containsAll(c) is true when c contains a subset of elements
-     */
-    public void testContainsAll() {
-        DelayQueue q = populatedQueue(SIZE);
-        DelayQueue p = new DelayQueue();
-        for (int i = 0; i < SIZE; ++i) {
-            assertTrue(q.containsAll(p));
-            assertFalse(p.containsAll(q));
-            p.add(new PDelay(i));
-        }
-        assertTrue(p.containsAll(q));
-    }
-
-    /**
-     * retainAll(c) retains only those elements of c and reports true if changed
-     */
-    public void testRetainAll() {
-        DelayQueue q = populatedQueue(SIZE);
-        DelayQueue p = populatedQueue(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) {
-            DelayQueue q = populatedQueue(SIZE);
-            DelayQueue p = populatedQueue(i);
-            assertTrue(q.removeAll(p));
-            assertEquals(SIZE-i, q.size());
-            for (int j = 0; j < i; ++j) {
-                PDelay I = (PDelay)(p.remove());
-                assertFalse(q.contains(I));
-            }
-        }
-    }
-
-    /**
-     * toArray contains all elements
-     */
-    public void testToArray() throws InterruptedException {
-        DelayQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        Arrays.sort(o);
-        for (int i = 0; i < o.length; i++)
-            assertEquals(o[i], q.take());
-    }
-
-    /**
-     * toArray(a) contains all elements
-     */
-    public void testToArray2() throws InterruptedException {
-        DelayQueue q = populatedQueue(SIZE);
-        PDelay[] ints = new PDelay[SIZE];
-        ints = (PDelay[])q.toArray(ints);
-        Arrays.sort(ints);
-        for (int i = 0; i < ints.length; i++)
-            assertEquals(ints[i], q.take());
-    }
-
-
-    /**
-     * toArray(null) throws NPE
-     */
-    public void testToArray_BadArg() {
-        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() {
-        DelayQueue q = populatedQueue(SIZE);
-        try {
-            Object o[] = q.toArray(new String[10]);
-            shouldThrow();
-        } catch (ArrayStoreException success) {}
-    }
-
-    /**
-     * iterator iterates through all elements
-     */
-    public void testIterator() {
-        DelayQueue q = populatedQueue(SIZE);
-        int i = 0;
-        Iterator it = q.iterator();
-        while (it.hasNext()) {
-            assertTrue(q.contains(it.next()));
-            ++i;
-        }
-        assertEquals(i, SIZE);
-    }
-
-    /**
-     * iterator.remove removes current element
-     */
-    public void testIteratorRemove () {
-        final DelayQueue q = new DelayQueue();
-        q.add(new PDelay(2));
-        q.add(new PDelay(1));
-        q.add(new PDelay(3));
-        Iterator it = q.iterator();
-        it.next();
-        it.remove();
-        it = q.iterator();
-        assertEquals(it.next(), new PDelay(2));
-        assertEquals(it.next(), new PDelay(3));
-        assertFalse(it.hasNext());
-    }
-
-
-    /**
-     * toString contains toStrings of elements
-     */
-    public void testToString() {
-        DelayQueue q = populatedQueue(SIZE);
-        String s = q.toString();
-        for (int i = 0; i < SIZE; ++i) {
-            assertTrue(s.indexOf(String.valueOf(Integer.MIN_VALUE+i)) >= 0);
-        }
-    }
-
-    /**
-     * offer transfers elements across Executor tasks
-     */
-    public void testPollInExecutor() {
-        final DelayQueue q = new DelayQueue();
-        ExecutorService executor = Executors.newFixedThreadPool(2);
-        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));
-            }});
-
-        joinPool(executor);
-    }
-
-
-    /**
-     * Delayed actions do not occur until their delay elapses
-     */
-    public void testDelay() throws InterruptedException {
-        DelayQueue q = new DelayQueue();
-        NanoDelay[] elements = new NanoDelay[SIZE];
-        for (int i = 0; i < SIZE; ++i) {
-            elements[i] = new NanoDelay(1000000000L + 1000000L * (SIZE - i));
-        }
-        for (int i = 0; i < SIZE; ++i) {
-            q.add(elements[i]);
-        }
-
-        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;
-        }
-    }
-
-    /**
-     * peek of a non-empty queue returns non-null even if not expired
-     */
-    public void testPeekDelayed() {
-        DelayQueue q = new DelayQueue();
-        q.add(new NanoDelay(Long.MAX_VALUE));
-        assert(q.peek() != null);
-    }
-
-
-    /**
-     * poll of a non-empty queue returns null if no expired elements.
-     */
-    public void testPollDelayed() {
-        DelayQueue q = new DelayQueue();
-        q.add(new NanoDelay(Long.MAX_VALUE));
-        assertNull(q.poll());
-    }
-
-    /**
-     * timed poll of a non-empty queue returns null if no expired elements.
-     */
-    public void testTimedPollDelayed() throws InterruptedException {
-        DelayQueue q = new DelayQueue();
-        q.add(new NanoDelay(LONG_DELAY_MS * 1000000L));
-        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
-    }
-
-    /**
-     * drainTo(null) throws NPE
-     */
-    public void testDrainToNull() {
-        DelayQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * drainTo(this) throws IAE
-     */
-    public void testDrainToSelf() {
-        DelayQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * drainTo(c) empties queue into another collection c
-     */
-    public void testDrainTo() {
-        DelayQueue q = new DelayQueue();
-        PDelay[] elems = new PDelay[SIZE];
-        for (int i = 0; i < SIZE; ++i) {
-            elems[i] = new PDelay(i);
-            q.add(elems[i]);
-        }
-        ArrayList l = new ArrayList();
-        q.drainTo(l);
-        assertEquals(q.size(), 0);
-        for (int i = 0; i < SIZE; ++i)
-            assertEquals(l.get(i), elems[i]);
-        q.add(elems[0]);
-        q.add(elems[1]);
-        assertFalse(q.isEmpty());
-        assertTrue(q.contains(elems[0]));
-        assertTrue(q.contains(elems[1]));
-        l.clear();
-        q.drainTo(l);
-        assertEquals(q.size(), 0);
-        assertEquals(l.size(), 2);
-        for (int i = 0; i < 2; ++i)
-            assertEquals(l.get(i), elems[i]);
-    }
-
-    /**
-     * drainTo empties queue
-     */
-    public void testDrainToWithActivePut() throws InterruptedException {
-        final DelayQueue q = populatedQueue(SIZE);
-        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) {}
-    }
-
-    /**
-     * drainTo(this, n) throws IAE
-     */
-    public void testDrainToSelfN() {
-        DelayQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(q, 0);
-            shouldThrow();
-        } 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);
-            ArrayList l = new ArrayList();
-            q.drainTo(l, i);
-            int k = (i < SIZE)? i : SIZE;
-            assertEquals(q.size(), SIZE-k);
-            assertEquals(l.size(), k);
-        }
-    }
-
-
-}
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
deleted file mode 100644
index 893fd48..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/EntryTest.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * 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
deleted file mode 100755
index be1eaa3..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ExchangerTest.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * 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;
-
-public class ExchangerTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(ExchangerTest.class);
-    }
-
-    /**
-     * exchange exchanges objects across two threads
-     */
-    public void testExchange() throws InterruptedException {
-        final Exchanger e = new Exchanger();
-        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() throws InterruptedException {
-        final Exchanger e = new Exchanger();
-        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() throws InterruptedException {
-        final Exchanger e = new Exchanger();
-        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() throws InterruptedException {
-        final Exchanger e = new Exchanger();
-        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() throws InterruptedException {
-        final Exchanger e = new Exchanger();
-        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() throws InterruptedException {
-        final Exchanger e = new Exchanger();
-        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
deleted file mode 100644
index dfa8f7d..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ExecutorCompletionServiceTest.java
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
- * 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.atomic.*;
-import java.math.BigInteger;
-import java.security.*;
-
-public class ExecutorCompletionServiceTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(ExecutorCompletionServiceTest.class);
-    }
-
-
-    /**
-     * Creating a new ECS with null Executor throw NPE
-     */
-    public void testConstructorNPE() {
-        try {
-            ExecutorCompletionService ecs = new ExecutorCompletionService(null);
-            shouldThrow();
-        } 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) {}
-    }
-
-    /**
-     * Submitting a null callable throws NPE
-     */
-    public void testSubmitNPE() {
-        ExecutorService e = Executors.newCachedThreadPool();
-        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
-        try {
-            Callable c = null;
-            ecs.submit(c);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * Submitting a null runnable throws NPE
-     */
-    public void testSubmitNPE2() {
-        ExecutorService e = Executors.newCachedThreadPool();
-        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
-        try {
-            Runnable r = null;
-            ecs.submit(r, Boolean.TRUE);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * A taken submitted task is completed
-     */
-    public void testTake() throws InterruptedException {
-        ExecutorService e = Executors.newCachedThreadPool();
-        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
-        try {
-            Callable c = new StringTask();
-            ecs.submit(c);
-            Future f = ecs.take();
-            assertTrue(f.isDone());
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * Take returns the same future object returned by submit
-     */
-    public void testTake2() throws InterruptedException {
-        ExecutorService e = Executors.newCachedThreadPool();
-        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
-        try {
-            Callable c = new StringTask();
-            Future f1 = ecs.submit(c);
-            Future f2 = ecs.take();
-            assertSame(f1, f2);
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * If poll returns non-null, the returned task is completed
-     */
-    public void testPoll1() throws InterruptedException {
-        ExecutorService e = Executors.newCachedThreadPool();
-        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
-        try {
-            assertNull(ecs.poll());
-            Callable c = new StringTask();
-            ecs.submit(c);
-            Thread.sleep(SHORT_DELAY_MS);
-            for (;;) {
-                Future f = ecs.poll();
-                if (f != null) {
-                    assertTrue(f.isDone());
-                    break;
-                }
-            }
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * If timed poll returns non-null, the returned task is completed
-     */
-    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, MILLISECONDS);
-            if (f != null)
-                assertTrue(f.isDone());
-        } 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
deleted file mode 100755
index f29a712..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ExecutorsTest.java
+++ /dev/null
@@ -1,556 +0,0 @@
-/*
- * 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.math.BigInteger;
-import java.security.*;
-
-public class ExecutorsTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(ExecutorsTest.class);
-    }
-
-    /**
-     * A newCachedThreadPool can execute runnables
-     */
-    public void testNewCachedThreadPool1() {
-        ExecutorService e = Executors.newCachedThreadPool();
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        joinPool(e);
-    }
-
-    /**
-     * A newCachedThreadPool with given ThreadFactory can execute runnables
-     */
-    public void testNewCachedThreadPool2() {
-        ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        joinPool(e);
-    }
-
-    /**
-     * A newCachedThreadPool with null ThreadFactory throws NPE
-     */
-    public void testNewCachedThreadPool3() {
-        try {
-            ExecutorService e = Executors.newCachedThreadPool(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * A new SingleThreadExecutor can execute runnables
-     */
-    public void testNewSingleThreadExecutor1() {
-        ExecutorService e = Executors.newSingleThreadExecutor();
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        joinPool(e);
-    }
-
-    /**
-     * A new SingleThreadExecutor with given ThreadFactory can execute runnables
-     */
-    public void testNewSingleThreadExecutor2() {
-        ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        joinPool(e);
-    }
-
-    /**
-     * A new SingleThreadExecutor with null ThreadFactory throws NPE
-     */
-    public void testNewSingleThreadExecutor3() {
-        try {
-            ExecutorService e = Executors.newSingleThreadExecutor(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * A new SingleThreadExecutor cannot be casted to concrete implementation
-     */
-    public void testCastNewSingleThreadExecutor() {
-        ExecutorService e = Executors.newSingleThreadExecutor();
-        try {
-            ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
-            shouldThrow();
-        } catch (ClassCastException success) {
-        } finally {
-            joinPool(e);
-        }
-    }
-
-
-    /**
-     * A new newFixedThreadPool can execute runnables
-     */
-    public void testNewFixedThreadPool1() {
-        ExecutorService e = Executors.newFixedThreadPool(2);
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        joinPool(e);
-    }
-
-    /**
-     * A new newFixedThreadPool with given ThreadFactory can execute runnables
-     */
-    public void testNewFixedThreadPool2() {
-        ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        joinPool(e);
-    }
-
-    /**
-     * A new newFixedThreadPool with null ThreadFactory throws NPE
-     */
-    public void testNewFixedThreadPool3() {
-        try {
-            ExecutorService e = Executors.newFixedThreadPool(2, null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * A new newFixedThreadPool with 0 threads throws IAE
-     */
-    public void testNewFixedThreadPool4() {
-        try {
-            ExecutorService e = Executors.newFixedThreadPool(0);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-
-    /**
-     * An unconfigurable newFixedThreadPool can execute runnables
-     */
-    public void testunconfigurableExecutorService() {
-        ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        e.execute(new NoOpRunnable());
-        joinPool(e);
-    }
-
-    /**
-     * unconfigurableExecutorService(null) throws NPE
-     */
-    public void testunconfigurableExecutorServiceNPE() {
-        try {
-            ExecutorService e = Executors.unconfigurableExecutorService(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * unconfigurableScheduledExecutorService(null) throws NPE
-     */
-    public void testunconfigurableScheduledExecutorServiceNPE() {
-        try {
-            ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * a newSingleThreadScheduledExecutor successfully runs delayed task
-     */
-    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() 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
-     */
-    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);
-    }
-
-    /**
-     *  Future.get on submitted tasks will time out if they compute too long.
-     */
-    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 {
-                    future.get(SHORT_DELAY_MS, MILLISECONDS);
-                    shouldThrow();
-                } catch (TimeoutException success) {
-                } finally {
-                    future.cancel(true);
-                }
-            }
-            finally {
-                joinPool(executor);
-            }
-        }
-    }
-
-
-    /**
-     * ThreadPoolExecutor using defaultThreadFactory has
-     * specified group, priority, daemon status, and name
-     */
-    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
-                    }
-                }
-            };
-        ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
-
-        e.execute(r);
-        try {
-            e.shutdown();
-        } catch (SecurityException ok) {
-        }
-
-        try {
-            Thread.sleep(SHORT_DELAY_MS);
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * ThreadPoolExecutor using privilegedThreadFactory has
-     * specified group, priority, daemon status, name,
-     * access control context and context class loader
-     */
-    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() {
-        SecurityManager sm = System.getSecurityManager();
-        if (sm != null) {
-            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
-            sm.checkPermission(new RuntimePermission("getClassLoader"));
-        }
-    }
-
-    class CheckCCL implements Callable<Object> {
-        public Object call() {
-            checkCCL();
-            return null;
-        }
-    }
-
-
-    /**
-     * Without class loader permissions, creating
-     * privilegedCallableUsingCurrentClassLoader throws ACE
-     */
-    public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
-        Runnable r = new CheckedRunnable() {
-            public void realRun() throws Exception {
-                if (System.getSecurityManager() == null)
-                    return;
-                try {
-                    Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
-                    shouldThrow();
-                } catch (AccessControlException success) {}
-            }};
-
-        runWithoutPermissions(r);
-    }
-
-    /**
-     * With class loader permissions, calling
-     * privilegedCallableUsingCurrentClassLoader does not throw ACE
-     */
-    public void testprivilegedCallableUsingCCLWithPrivs() throws Exception {
-        Runnable r = new CheckedRunnable() {
-            public void realRun() throws Exception {
-                Executors.privilegedCallableUsingCurrentClassLoader
-                    (new NoOpCallable())
-                    .call();
-            }};
-
-        runWithPermissions(r,
-                           new RuntimePermission("getClassLoader"),
-                           new RuntimePermission("setContextClassLoader"));
-    }
-
-    /**
-     * Without permissions, calling privilegedCallable throws ACE
-     */
-    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() 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() throws Exception {
-        Callable c = Executors.callable(new NoOpRunnable());
-        assertNull(c.call());
-    }
-
-    /**
-     * callable(Runnable, result) returns result when called
-     */
-    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() 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() 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 {
-            Callable c = Executors.callable((Runnable) null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * callable(null, result) throws NPE
-     */
-    public void testCallableNPE2() {
-        try {
-            Callable c = Executors.callable((Runnable) null, one);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * callable(null PrivilegedAction) throws NPE
-     */
-    public void testCallableNPE3() {
-        try {
-            Callable c = Executors.callable((PrivilegedAction) null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * callable(null PrivilegedExceptionAction) throws NPE
-     */
-    public void testCallableNPE4() {
-        try {
-            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
deleted file mode 100755
index b1f9f40..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/FutureTaskTest.java
+++ /dev/null
@@ -1,358 +0,0 @@
-/*
- * 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.concurrent.*;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.util.*;
-
-public class FutureTaskTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(FutureTaskTest.class);
-    }
-
-    /**
-     * Subclass to expose protected methods
-     */
-    static class PublicFutureTask extends FutureTask {
-        public PublicFutureTask(Callable r) { super(r); }
-        public boolean runAndReset() { return super.runAndReset(); }
-        public void set(Object x) { super.set(x); }
-        public void setException(Throwable t) { super.setException(t); }
-    }
-
-    /**
-     * Creating a future with a null callable throws NPE
-     */
-    public void testConstructor() {
-        try {
-            FutureTask task = new FutureTask(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * creating a future with null runnable fails
-     */
-    public void testConstructor2() {
-        try {
-            FutureTask task = new FutureTask(null, Boolean.TRUE);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * isDone is true when a task completes
-     */
-    public void testIsDone() {
-        FutureTask task = new FutureTask(new NoOpCallable());
-        task.run();
-        assertTrue(task.isDone());
-        assertFalse(task.isCancelled());
-    }
-
-    /**
-     * runAndReset of a non-cancelled task succeeds
-     */
-    public void testRunAndReset() {
-        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
-        assertTrue(task.runAndReset());
-        assertFalse(task.isDone());
-    }
-
-    /**
-     * runAndReset after cancellation fails
-     */
-    public void testResetAfterCancel() {
-        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
-        assertTrue(task.cancel(false));
-        assertFalse(task.runAndReset());
-        assertTrue(task.isDone());
-        assertTrue(task.isCancelled());
-    }
-
-
-
-    /**
-     * setting value causes get to return it
-     */
-    public void testSet() throws Exception {
-        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
-        task.set(one);
-        assertSame(task.get(), one);
-    }
-
-    /**
-     * setException causes get to throw ExecutionException
-     */
-    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 success) {
-            assertSame(success.getCause(), nse);
-        }
-    }
-
-    /**
-     *  Cancelling before running succeeds
-     */
-    public void testCancelBeforeRun() {
-        FutureTask task = new FutureTask(new NoOpCallable());
-        assertTrue(task.cancel(false));
-        task.run();
-        assertTrue(task.isDone());
-        assertTrue(task.isCancelled());
-    }
-
-    /**
-     * Cancel(true) before run succeeds
-     */
-    public void testCancelBeforeRun2() {
-        FutureTask task = new FutureTask(new NoOpCallable());
-        assertTrue(task.cancel(true));
-        task.run();
-        assertTrue(task.isDone());
-        assertTrue(task.isCancelled());
-    }
-
-    /**
-     * cancel of a completed task fails
-     */
-    public void testCancelAfterRun() {
-        FutureTask task = new FutureTask(new NoOpCallable());
-        task.run();
-        assertFalse(task.cancel(false));
-        assertTrue(task.isDone());
-        assertFalse(task.isCancelled());
-    }
-
-    /**
-     * cancel(true) interrupts a running task
-     */
-    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);
-        t.start();
-        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() 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);
-        t.start();
-        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() throws InterruptedException {
-        final FutureTask ft =
-            new FutureTask(new CheckedCallable<Object>() {
-                public Object realCall() throws InterruptedException {
-                    return Boolean.TRUE;
-                }});
-        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() throws InterruptedException {
-        final FutureTask ft =
-            new FutureTask(new CheckedCallable<Object>() {
-                public Object realCall() throws InterruptedException {
-                    return Boolean.TRUE;
-                }});
-        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() throws InterruptedException {
-        final FutureTask ft =
-            new FutureTask(new CheckedInterruptedCallable<Object>() {
-                public Object realCall() throws InterruptedException {
-                    Thread.sleep(SMALL_DELAY_MS);
-                    return Boolean.TRUE;
-                }});
-
-        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() throws InterruptedException {
-        final FutureTask ft =
-            new FutureTask(new CheckedInterruptedCallable<Object>() {
-                public Object realCall() throws InterruptedException {
-                    Thread.sleep(SMALL_DELAY_MS);
-                    return Boolean.TRUE;
-                }});
-        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() throws InterruptedException {
-        final FutureTask ft = new FutureTask(new Callable() {
-            public Object call() {
-                return 5/0;
-            }});
-
-        ft.run();
-        try {
-            ft.get();
-            shouldThrow();
-        } catch (ExecutionException success) {
-            assertTrue(success.getCause() instanceof ArithmeticException);
-        }
-    }
-
-    /**
-     *  A runtime exception in task causes timed get to throw ExecutionException
-     */
-    public void testTimedGet_ExecutionException2() throws Exception {
-        final FutureTask ft = new FutureTask(new Callable() {
-            public Object call() {
-                return 5/0;
-            }});
-
-        ft.run();
-        try {
-            ft.get(SHORT_DELAY_MS, MILLISECONDS);
-            shouldThrow();
-        } catch (ExecutionException success) {
-            assertTrue(success.getCause() instanceof ArithmeticException);
-        }
-    }
-
-
-    /**
-     * Interrupting a waiting get causes it to throw InterruptedException
-     */
-    public void testGet_InterruptedException() throws InterruptedException {
-        final FutureTask ft = new FutureTask(new NoOpCallable());
-        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() throws InterruptedException {
-        final FutureTask ft = new FutureTask(new NoOpCallable());
-        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() throws Exception {
-        try {
-            FutureTask ft = new FutureTask(new NoOpCallable());
-            ft.get(1,MILLISECONDS);
-            shouldThrow();
-        } 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
deleted file mode 100644
index b764855..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/JSR166TestCase.java
+++ /dev/null
@@ -1,761 +0,0 @@
-/*
- * 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.io.*;
-import java.security.*;
-
-/**
- * Base class for JSR166 Junit TCK tests.  Defines some constants,
- * utility methods and classes, as well as a simple framework for
- * helping to make sure that assertions failing in generated threads
- * cause the associated test that generated them to itself fail (which
- * JUnit does not otherwise arrange).  The rules for creating such
- * tests are:
- *
- * <ol>
- *
- * <li> All assertions in code running in generated threads must use
- * the forms {@link #threadFail}, {@link #threadAssertTrue}, {@link
- * #threadAssertEquals}, or {@link #threadAssertNull}, (not
- * <tt>fail</tt>, <tt>assertTrue</tt>, etc.) It is OK (but not
- * particularly recommended) for other code to use these forms too.
- * Only the most typically used JUnit assertion methods are defined
- * this way, but enough to live with.</li>
- *
- * <li> If you override {@link #setUp} or {@link #tearDown}, make sure
- * to invoke <tt>super.setUp</tt> and <tt>super.tearDown</tt> within
- * them. These methods are used to clear and check for thread
- * assertion failures.</li>
- *
- * <li>All delays and timeouts must use one of the constants <tt>
- * SHORT_DELAY_MS</tt>, <tt> SMALL_DELAY_MS</tt>, <tt> MEDIUM_DELAY_MS</tt>,
- * <tt> LONG_DELAY_MS</tt>. The idea here is that a SHORT is always
- * discriminable from zero time, and always allows enough time for the
- * small amounts of computation (creating a thread, calling a few
- * methods, etc) needed to reach a timeout point. Similarly, a SMALL
- * is always discriminable as larger than SHORT and smaller than
- * MEDIUM.  And so on. These constants are set to conservative values,
- * but even so, if there is ever any doubt, they can all be increased
- * in one spot to rerun tests on slower platforms.</li>
- *
- * <li> All threads generated must be joined inside each test case
- * method (or <tt>fail</tt> to do so) before returning from the
- * method. The <tt> joinPool</tt> method can be used to do this when
- * using Executors.</li>
- *
- * </ol>
- *
- * <p> <b>Other notes</b>
- * <ul>
- *
- * <li> Usually, there is one testcase method per JSR166 method
- * covering "normal" operation, and then as many exception-testing
- * methods as there are exceptions the method can throw. Sometimes
- * there are multiple tests per JSR166 method when the different
- * "normal" behaviors differ significantly. And sometimes testcases
- * cover multiple methods when they cannot be tested in
- * isolation.</li>
- *
- * <li> The documentation style for testcases is to provide as javadoc
- * a simple sentence or two describing the property that the testcase
- * method purports to test. The javadocs do not say anything about how
- * the property is tested. To find out, read the code.</li>
- *
- * <li> These tests are "conformance tests", and do not attempt to
- * test throughput, latency, scalability or other performance factors
- * (see the separate "jtreg" tests for a set intended to check these
- * for the most central aspects of functionality.) So, most tests use
- * the smallest sensible numbers of threads, collection sizes, etc
- * needed to check basic conformance.</li>
- *
- * <li>The test classes currently do not declare inclusion in
- * any particular package to simplify things for people integrating
- * them in TCK test suites.</li>
- *
- * <li> As a convenience, the <tt>main</tt> of this class (JSR166TestCase)
- * runs all JSR166 unit tests.</li>
- *
- * </ul>
- */
-public class JSR166TestCase extends TestCase {
-    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() {
-        TestSuite suite = new TestSuite("JSR166 Unit Tests");
-
-        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;
-    }
-
-
-    public static long SHORT_DELAY_MS;
-    public static long SMALL_DELAY_MS;
-    public static long MEDIUM_DELAY_MS;
-    public static long LONG_DELAY_MS;
-
-
-    /**
-     * Returns the shortest timed delay. This could
-     * be reimplemented to use for example a Property.
-     */
-    protected long getShortDelay() {
-        // BEGIN android-changed
-        // original value is 50
-        return 250;
-        // END android-changed
-    }
-
-
-    /**
-     * Sets delays as multiples of SHORT_DELAY.
-     */
-    protected void setDelays() {
-        SHORT_DELAY_MS = getShortDelay();
-        SMALL_DELAY_MS = SHORT_DELAY_MS * 5;
-        MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10;
-        LONG_DELAY_MS = SHORT_DELAY_MS * 50;
-    }
-
-    /**
-     * Flag set true if any threadAssert methods fail
-     */
-    volatile boolean threadFailed;
-
-    /**
-     * Initializes test to indicate that no thread assertions have failed
-     */
-    public void setUp() {
-        setDelays();
-        threadFailed = false;
-    }
-
-    /**
-     * Triggers test case failure if any thread assertions have failed
-     */
-    public void tearDown() {
-        assertFalse(threadFailed);
-    }
-
-    /**
-     * Fail, also setting status to indicate current testcase should fail
-     */
-    public void threadFail(String reason) {
-        threadFailed = true;
-        fail(reason);
-    }
-
-    /**
-     * If expression not true, set status to indicate current testcase
-     * should fail
-     */
-    public void threadAssertTrue(boolean b) {
-        if (!b) {
-            threadFailed = true;
-            assertTrue(b);
-        }
-    }
-
-    /**
-     * If expression not false, set status to indicate current testcase
-     * should fail
-     */
-    public void threadAssertFalse(boolean b) {
-        if (b) {
-            threadFailed = true;
-            assertFalse(b);
-        }
-    }
-
-    /**
-     * If argument not null, set status to indicate current testcase
-     * should fail
-     */
-    public void threadAssertNull(Object x) {
-        if (x != null) {
-            threadFailed = true;
-            assertNull(x);
-        }
-    }
-
-    /**
-     * If arguments not equal, set status to indicate current testcase
-     * should fail
-     */
-    public void threadAssertEquals(long x, long y) {
-        if (x != y) {
-            threadFailed = true;
-            assertEquals(x, y);
-        }
-    }
-
-    /**
-     * If arguments not equal, set status to indicate current testcase
-     * should fail
-     */
-    public void threadAssertEquals(Object x, Object y) {
-        if (x != y && (x == null || !x.equals(y))) {
-            threadFailed = true;
-            assertEquals(x, y);
-        }
-    }
-
-    /**
-     * threadFail with message "should throw exception"
-     */
-    public void threadShouldThrow() {
-        threadFailed = true;
-        fail("should throw exception");
-    }
-
-    /**
-     * threadFail with message "should throw" + exceptionName
-     */
-    public void threadShouldThrow(String exceptionName) {
-        threadFailed = true;
-        fail("should throw " + exceptionName);
-    }
-
-    /**
-     * threadFail with message "Unexpected exception"
-     */
-    public void threadUnexpectedException() {
-        threadFailed = true;
-        fail("Unexpected exception");
-    }
-
-    /**
-     * threadFail with message "Unexpected exception", with argument
-     */
-    public void threadUnexpectedException(Throwable ex) {
-        threadFailed = true;
-        ex.printStackTrace();
-        fail("Unexpected exception: " + ex);
-    }
-
-    /**
-     * Wait out termination of a thread pool or fail doing so
-     */
-    public void joinPool(ExecutorService exec) {
-        try {
-            exec.shutdown();
-            assertTrue(exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
-        } catch (SecurityException ok) {
-            // Allowed in case test doesn't have privs
-        } catch (InterruptedException ie) {
-            fail("Unexpected InterruptedException");
-        }
-    }
-
-
-    /**
-     * fail with message "should throw exception"
-     */
-    public void shouldThrow() {
-        fail("Should throw exception");
-    }
-
-    /**
-     * 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.
-     */
-    public static final int SIZE = 20;
-
-    // Some convenient Integer constants
-
-    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.
-     */
-    public static class AdjustablePolicy extends java.security.Policy {
-        Permissions perms = new Permissions();
-        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) {
-            return perms;
-        }
-        public PermissionCollection getPermissions(ProtectionDomain pd) {
-            return perms;
-        }
-        public boolean implies(ProtectionDomain pd, Permission p) {
-            return perms.implies(p);
-        }
-        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"));
-    }
-
-    /**
-     * 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) {}
-    }
-
-    /**
-     * Returns a new started Thread running the given runnable.
-     */
-    Thread newStartedThread(Runnable runnable) {
-        Thread t = new Thread(runnable);
-        t.start();
-        return t;
-    }
-
-    // Some convenient Runnable classes
-
-    public abstract class CheckedRunnable implements Runnable {
-        protected abstract void realRun() throws Throwable;
-
-        public final void run() {
-            try {
-                realRun();
-            } catch (Throwable t) {
-                threadUnexpectedException(t);
-            }
-        }
-    }
-
-    public abstract class RunnableShouldThrow implements Runnable {
-        protected abstract void realRun() throws Throwable;
-
-        final Class<?> exceptionClass;
-
-        <T extends Throwable> RunnableShouldThrow(Class<T> exceptionClass) {
-            this.exceptionClass = exceptionClass;
-        }
-
-        public final void run() {
-            try {
-                realRun();
-                threadShouldThrow(exceptionClass.getSimpleName());
-            } catch (Throwable t) {
-                if (! exceptionClass.isInstance(t))
-                    threadUnexpectedException(t);
-            }
-        }
-    }
-
-    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 {
-                realRun();
-                threadShouldThrow(exceptionClass.getSimpleName());
-            } catch (Throwable t) {
-                if (! exceptionClass.isInstance(t))
-                    threadUnexpectedException(t);
-            }
-        }
-    }
-
-    public abstract class CheckedInterruptedRunnable implements Runnable {
-        protected abstract void realRun() throws Throwable;
-
-        public final void run() {
-            try {
-                realRun();
-                threadShouldThrow("InterruptedException");
-            } catch (InterruptedException success) {
-            } catch (Throwable t) {
-                threadUnexpectedException(t);
-            }
-        }
-    }
-
-    public abstract class CheckedCallable<T> implements Callable<T> {
-        protected abstract T realCall() throws Throwable;
-
-        public final T call() {
-            try {
-                return realCall();
-            } catch (Throwable t) {
-                threadUnexpectedException(t);
-            }
-            return null;
-        }
-    }
-
-    public abstract class CheckedInterruptedCallable<T> implements Callable<T> {
-        protected abstract T realCall() throws Throwable;
-
-        public final T call() {
-            try {
-                T result = realCall();
-                threadShouldThrow("InterruptedException");
-                return result;
-            } catch (InterruptedException success) {
-            } catch (Throwable t) {
-                threadUnexpectedException(t);
-            }
-            return null;
-        }
-    }
-
-    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);
-            } catch (InterruptedException ok) {}
-        }
-    }
-
-    public class SmallCallable extends CheckedCallable {
-        protected Object realCall() throws InterruptedException {
-            Thread.sleep(SMALL_DELAY_MS);
-            return Boolean.TRUE;
-        }
-    }
-
-    public class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
-        protected void realRun() throws InterruptedException {
-            Thread.sleep(SMALL_DELAY_MS);
-        }
-    }
-
-    public class MediumRunnable extends CheckedRunnable {
-        protected void realRun() throws Throwable {
-            Thread.sleep(MEDIUM_DELAY_MS);
-        }
-    }
-
-    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 ok) {}
-        }
-    }
-
-    public class LongPossiblyInterruptedRunnable extends CheckedRunnable {
-        protected void realRun() {
-            try {
-                Thread.sleep(LONG_DELAY_MS);
-            } catch (InterruptedException ok) {}
-        }
-    }
-
-    /**
-     * For use as ThreadFactory in constructors
-     */
-    public static class SimpleThreadFactory implements ThreadFactory {
-        public Thread newThread(Runnable r) {
-            return new Thread(r);
-        }
-    }
-
-    public static class TrackedShortRunnable implements Runnable {
-        public volatile boolean done = false;
-        public void run() {
-            try {
-                Thread.sleep(SMALL_DELAY_MS);
-                done = true;
-            } catch (InterruptedException ok) {}
-        }
-    }
-
-    public static class TrackedMediumRunnable implements Runnable {
-        public volatile boolean done = false;
-        public void run() {
-            try {
-                Thread.sleep(MEDIUM_DELAY_MS);
-                done = true;
-            } catch (InterruptedException ok) {}
-        }
-    }
-
-    public static class TrackedLongRunnable implements Runnable {
-        public volatile boolean done = false;
-        public void run() {
-            try {
-                Thread.sleep(LONG_DELAY_MS);
-                done = true;
-            } catch (InterruptedException ok) {}
-        }
-    }
-
-    public static class TrackedNoOpRunnable implements Runnable {
-        public volatile boolean done = false;
-        public void run() {
-            done = true;
-        }
-    }
-
-    public static class TrackedCallable implements Callable {
-        public volatile boolean done = false;
-        public Object call() {
-            try {
-                Thread.sleep(SMALL_DELAY_MS);
-                done = true;
-            } catch (InterruptedException ok) {}
-            return Boolean.TRUE;
-        }
-    }
-
-
-    /**
-     * For use as RejectedExecutionHandler in constructors
-     */
-    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
deleted file mode 100644
index a858bb9..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/LinkedBlockingDequeTest.java
+++ /dev/null
@@ -1,1671 +0,0 @@
-/*
- * 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
deleted file mode 100755
index a98dc21..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/LinkedBlockingQueueTest.java
+++ /dev/null
@@ -1,919 +0,0 @@
-/*
- * 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.io.*;
-
-public class LinkedBlockingQueueTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(LinkedBlockingQueueTest.class);
-    }
-
-
-    /**
-     * Create a queue of given size containing consecutive
-     * Integers 0 ... n.
-     */
-    private LinkedBlockingQueue populatedQueue(int n) {
-        LinkedBlockingQueue q = new LinkedBlockingQueue(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;
-    }
-
-    /**
-     * A new queue has the indicated capacity, or Integer.MAX_VALUE if
-     * none given
-     */
-    public void testConstructor1() {
-        assertEquals(SIZE, new LinkedBlockingQueue(SIZE).remainingCapacity());
-        assertEquals(Integer.MAX_VALUE, new LinkedBlockingQueue().remainingCapacity());
-    }
-
-    /**
-     * Constructor throws IAE if capacity argument nonpositive
-     */
-    public void testConstructor2() {
-        try {
-            LinkedBlockingQueue q = new LinkedBlockingQueue(0);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * Initializing from null Collection throws NPE
-     */
-    public void testConstructor3() {
-        try {
-            LinkedBlockingQueue q = new LinkedBlockingQueue(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Initializing from Collection of null elements throws NPE
-     */
-    public void testConstructor4() {
-        try {
-            Integer[] ints = new Integer[SIZE];
-            LinkedBlockingQueue q = new LinkedBlockingQueue(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);
-            LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints));
-            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);
-        LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints));
-        for (int i = 0; i < SIZE; ++i)
-            assertEquals(ints[i], q.poll());
-    }
-
-    /**
-     * Queue transitions from empty to full when elements added
-     */
-    public void testEmptyFull() {
-        LinkedBlockingQueue q = new LinkedBlockingQueue(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() {
-        LinkedBlockingQueue q = populatedQueue(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 {
-            LinkedBlockingQueue q = new LinkedBlockingQueue(1);
-            q.offer(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * add(null) throws NPE
-     */
-    public void testAddNull() {
-        try {
-            LinkedBlockingQueue q = new LinkedBlockingQueue(1);
-            q.add(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Offer succeeds if not full; fails if full
-     */
-    public void testOffer() {
-        LinkedBlockingQueue q = new LinkedBlockingQueue(1);
-        assertTrue(q.offer(zero));
-        assertFalse(q.offer(one));
-    }
-
-    /**
-     * add succeeds if not full; throws ISE if full
-     */
-    public void testAdd() {
-        try {
-            LinkedBlockingQueue q = new LinkedBlockingQueue(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 {
-            LinkedBlockingQueue q = new LinkedBlockingQueue(1);
-            q.addAll(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * addAll(this) throws IAE
-     */
-    public void testAddAllSelf() {
-        try {
-            LinkedBlockingQueue q = populatedQueue(SIZE);
-            q.addAll(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * addAll of a collection with null elements throws NPE
-     */
-    public void testAddAll2() {
-        try {
-            LinkedBlockingQueue q = new LinkedBlockingQueue(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 {
-            LinkedBlockingQueue q = new LinkedBlockingQueue(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 {
-            LinkedBlockingQueue q = new LinkedBlockingQueue(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) {}
-    }
-    /**
-     * 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);
-        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() throws InterruptedException {
-        try {
-            LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
-            q.put(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-     }
-
-    /**
-     * all elements successfully put are contained
-     */
-    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() 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();
-        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 LinkedBlockingQueue q = new LinkedBlockingQueue(2);
-        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 LinkedBlockingQueue q = new LinkedBlockingQueue(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 {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.take());
-        }
-    }
-
-    /**
-     * take blocks interruptibly when empty
-     */
-    public void testTakeFromEmpty() throws InterruptedException {
-        final LinkedBlockingQueue q = new LinkedBlockingQueue(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 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();
-        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, q.poll());
-        }
-        assertNull(q.poll());
-    }
-
-    /**
-     * timed pool with zero timeout succeeds when non-empty, else times out
-     */
-    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() 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() 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();
-        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 LinkedBlockingQueue q = new LinkedBlockingQueue(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();
-    }
-
-    /**
-     * peek returns next element, or null if empty
-     */
-    public void testPeek() {
-        LinkedBlockingQueue q = populatedQueue(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());
-    }
-
-    /**
-     * element returns next element, or throws NSEE if empty
-     */
-    public void testElement() {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.element());
-            assertEquals(i, q.poll());
-        }
-        try {
-            q.element();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove removes next element, or throws NSEE if empty
-     */
-    public void testRemove() {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.remove());
-        }
-        try {
-            q.remove();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove(x) removes x and returns true if present
-     */
-    public void testRemoveElement() {
-        LinkedBlockingQueue q = populatedQueue(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());
-    }
-
-    /**
-     * An add following remove(x) succeeds
-     */
-    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);
-    }
-
-    /**
-     * contains(x) reports true when elements added but not yet removed
-     */
-    public void testContains() {
-        LinkedBlockingQueue q = populatedQueue(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() {
-        LinkedBlockingQueue q = populatedQueue(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() {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        LinkedBlockingQueue p = new LinkedBlockingQueue(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() {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        LinkedBlockingQueue p = populatedQueue(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) {
-            LinkedBlockingQueue q = populatedQueue(SIZE);
-            LinkedBlockingQueue p = populatedQueue(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 {
-        LinkedBlockingQueue q = populatedQueue(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 {
-        LinkedBlockingQueue q = populatedQueue(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() {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        try {
-            Object o[] = q.toArray(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * toArray with incompatible array type throws CCE
-     */
-    public void testToArray1_BadArg() {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        try {
-            Object o[] = q.toArray(new String[10]);
-            shouldThrow();
-        } catch (ArrayStoreException success) {}
-    }
-
-
-    /**
-     * iterator iterates through all elements
-     */
-    public void testIterator() throws InterruptedException {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        Iterator it = q.iterator();
-        while (it.hasNext()) {
-            assertEquals(it.next(), q.take());
-        }
-    }
-
-    /**
-     * iterator.remove removes current element
-     */
-    public void testIteratorRemove () {
-        final LinkedBlockingQueue q = new LinkedBlockingQueue(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 LinkedBlockingQueue q = new LinkedBlockingQueue(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 LinkedBlockingQueue q = new LinkedBlockingQueue(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());
-    }
-
-
-    /**
-     * toString contains toStrings of elements
-     */
-    public void testToString() {
-        LinkedBlockingQueue q = populatedQueue(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 LinkedBlockingQueue q = new LinkedBlockingQueue(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 LinkedBlockingQueue q = new LinkedBlockingQueue(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 queue has same elements in same order
-     */
-    public void testSerialization() throws Exception {
-        LinkedBlockingQueue q = populatedQueue(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));
-        LinkedBlockingQueue r = (LinkedBlockingQueue)in.readObject();
-        assertEquals(q.size(), r.size());
-        while (!q.isEmpty())
-            assertEquals(q.remove(), r.remove());
-    }
-
-    /**
-     * drainTo(null) throws NPE
-     */
-    public void testDrainToNull() {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * drainTo(this) throws IAE
-     */
-    public void testDrainToSelf() {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * drainTo(c) empties queue into another collection c
-     */
-    public void testDrainTo() {
-        LinkedBlockingQueue 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)
-            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 queue, unblocking a waiting put.
-     */
-    public void testDrainToWithActivePut() throws InterruptedException {
-        final LinkedBlockingQueue q = populatedQueue(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() {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(null, 0);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * drainTo(this, n) throws IAE
-     */
-    public void testDrainToSelfN() {
-        LinkedBlockingQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(q, 0);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * drainTo(c, n) empties first max {n, size} elements of queue into c
-     */
-    public void testDrainToN() {
-        LinkedBlockingQueue q = new LinkedBlockingQueue();
-        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/LinkedListTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/LinkedListTest.java
deleted file mode 100755
index 3017c52..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/LinkedListTest.java
+++ /dev/null
@@ -1,449 +0,0 @@
-/*
- * 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;
-
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.*;
-
-public class LinkedListTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(LinkedListTest.class);
-    }
-
-    /**
-     * Create a queue of given size containing consecutive
-     * Integers 0 ... n.
-     */
-    private LinkedList populatedQueue(int n) {
-        LinkedList q = new LinkedList();
-        assertTrue(q.isEmpty());
-        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
-     */
-    public void testConstructor1() {
-        assertEquals(0, new LinkedList().size());
-    }
-
-    /**
-     * Initializing from null Collection throws NPE
-     */
-    public void testConstructor3() {
-        try {
-            LinkedList q = new LinkedList((Collection)null);
-            shouldThrow();
-        }
-        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);
-            LinkedList q = new LinkedList(Arrays.asList(ints));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(ints[i], q.poll());
-        }
-        finally {}
-    }
-
-    /**
-     * isEmpty is true before add, false after
-     */
-    public void testEmpty() {
-        LinkedList q = new LinkedList();
-        assertTrue(q.isEmpty());
-        q.add(new Integer(1));
-        assertFalse(q.isEmpty());
-        q.add(new Integer(2));
-        q.remove();
-        q.remove();
-        assertTrue(q.isEmpty());
-    }
-
-    /**
-     * size changes when elements added and removed
-     */
-    public void testSize() {
-        LinkedList q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(SIZE-i, q.size());
-            q.remove();
-        }
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.size());
-            q.add(new Integer(i));
-        }
-    }
-
-    /**
-     * offer(null) succeeds
-     */
-    public void testOfferNull() {
-        try {
-            LinkedList q = new LinkedList();
-            q.offer(null);
-        } catch (NullPointerException ie) { 
-            unexpectedException();
-        }   
-    }
-
-    /**
-     * Offer succeeds 
-     */
-    public void testOffer() {
-        LinkedList q = new LinkedList();
-        assertTrue(q.offer(new Integer(0)));
-        assertTrue(q.offer(new Integer(1)));
-    }
-
-    /**
-     * add succeeds
-     */
-    public void testAdd() {
-        LinkedList q = new LinkedList();
-        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 {
-            LinkedList q = new LinkedList();
-            q.addAll(null);
-            shouldThrow();
-        }
-        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);
-            LinkedList q = new LinkedList();
-            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 {}
-    }
-
-    /**
-     * addAll with too large an index throws IOOBE
-     */
-    public void testAddAll2_IndexOutOfBoundsException() {
-        try {
-            LinkedList l = new LinkedList();
-            l.add(new Object());
-            LinkedList m = new LinkedList();
-            m.add(new Object());
-            l.addAll(4,m);
-            shouldThrow();
-        } catch(IndexOutOfBoundsException  success) {}
-    }
-
-    /**
-     * addAll with negative index throws IOOBE
-     */
-    public void testAddAll4_BadIndex() {
-        try {
-            LinkedList l = new LinkedList();
-            l.add(new Object());
-            LinkedList m = new LinkedList();
-            m.add(new Object());
-            l.addAll(-1,m);
-            shouldThrow();
-        } catch(IndexOutOfBoundsException  success){}
-    }
-
-    /**
-     *  poll succeeds unless empty
-     */
-    public void testPoll() {
-        LinkedList q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.poll()).intValue());
-        }
-        assertNull(q.poll());
-    }
-
-    /**
-     *  peek returns next element, or null if empty
-     */
-    public void testPeek() {
-        LinkedList q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.peek()).intValue());
-            q.poll();
-            assertTrue(q.peek() == null ||
-                       i != ((Integer)q.peek()).intValue());
-        }
-        assertNull(q.peek());
-    }
-
-    /**
-     * element returns next element, or throws NSEE if empty
-     */
-    public void testElement() {
-        LinkedList q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.element()).intValue());
-            q.poll();
-        }
-        try {
-            q.element();
-            shouldThrow();
-        }
-        catch (NoSuchElementException success) {}
-    }
-
-    /**
-     *  remove removes next element, or throws NSEE if empty
-     */
-    public void testRemove() {
-        LinkedList q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.remove()).intValue());
-        }
-        try {
-            q.remove();
-            shouldThrow();
-        } catch (NoSuchElementException success){
-        }   
-    }
-
-    /**
-     * remove(x) removes x and returns true if present
-     */
-    public void testRemoveElement() {
-        LinkedList q = populatedQueue(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() {
-        LinkedList q = populatedQueue(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() {
-        LinkedList q = populatedQueue(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() {
-        LinkedList q = populatedQueue(SIZE);
-        LinkedList p = new LinkedList();
-        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() {
-        LinkedList q = populatedQueue(SIZE);
-        LinkedList p = populatedQueue(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) {
-            LinkedList q = populatedQueue(SIZE);
-            LinkedList p = populatedQueue(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() {
-        LinkedList q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        Arrays.sort(o);
-        for(int i = 0; i < o.length; i++)
-            assertEquals(o[i], q.poll());
-    }
-
-    /**
-     *  toArray(a) contains all elements
-     */
-    public void testToArray2() {
-        LinkedList q = populatedQueue(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.poll());
-    }
-
-    /**
-     * toArray(null) throws NPE
-     */
-    public void testToArray_BadArg() {
-        try {
-            LinkedList l = new LinkedList();
-            l.add(new Object());
-            Object o[] = l.toArray(null);
-            shouldThrow();
-        } catch(NullPointerException success){}
-    }
-
-    /**
-     * toArray with incompatable aray type throws CCE
-     */
-    public void testToArray1_BadArg() {
-        try {
-            LinkedList l = new LinkedList();
-            l.add(new Integer(5));
-            Object o[] = l.toArray(new String[10] );
-            shouldThrow();
-        } catch(ArrayStoreException  success){}
-    }
-    
-    /**
-     *  iterator iterates through all elements
-     */
-    public void testIterator() {
-        LinkedList q = populatedQueue(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 LinkedList q = new LinkedList();
-        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();) {
-            int i = ((Integer)(it.next())).intValue();
-            assertEquals(++k, i);
-        }
-
-        assertEquals(3, k);
-    }
-
-    /**
-     * iterator.remove removes current element
-     */
-    public void testIteratorRemove () {
-        final LinkedList q = new LinkedList();
-        q.add(new Integer(1));
-        q.add(new Integer(2));
-        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() {
-        LinkedList q = populatedQueue(SIZE);
-        String s = q.toString();
-        for (int i = 0; i < SIZE; ++i) {
-            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
-        }
-    }        
-
-    /**
-     * peek returns element inserted with addFirst
-     */
-    public void testAddFirst() {
-        LinkedList q = populatedQueue(3);
-        q.addFirst(four);
-        assertEquals(four,q.peek());
-    }        
-
-}
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
deleted file mode 100755
index 1052a24..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/LockSupportTest.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * 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 java.util.concurrent.locks.*;
-
-public class LockSupportTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(LockSupportTest.class);
-    }
-
-    /**
-     * park is released by unpark occurring after park
-     */
-    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() 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() 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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        lock.lock();
-        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() 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() 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
deleted file mode 100755
index f1dd88d..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/PriorityBlockingQueueTest.java
+++ /dev/null
@@ -1,840 +0,0 @@
-/*
- * 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.io.*;
-
-public class PriorityBlockingQueueTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(PriorityBlockingQueueTest.class);
-    }
-
-    private static final int NOCAP = Integer.MAX_VALUE;
-
-    /** Sample Comparator */
-    static class MyReverseComparator implements Comparator {
-        public int compare(Object x, Object y) {
-            return ((Comparable)y).compareTo(x);
-        }
-    }
-
-    /**
-     * Create a queue of given size containing consecutive
-     * Integers 0 ... n.
-     */
-    private PriorityBlockingQueue populatedQueue(int n) {
-        PriorityBlockingQueue q = new PriorityBlockingQueue(n);
-        assertTrue(q.isEmpty());
-        for (int i = n-1; i >= 0; i-=2)
-            assertTrue(q.offer(new Integer(i)));
-        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
-     */
-    public void testConstructor1() {
-        assertEquals(NOCAP, new PriorityBlockingQueue(SIZE).remainingCapacity());
-    }
-
-    /**
-     * Constructor throws IAE if capacity argument nonpositive
-     */
-    public void testConstructor2() {
-        try {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(0);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * Initializing from null Collection throws NPE
-     */
-    public void testConstructor3() {
-        try {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Initializing from Collection of null elements throws NPE
-     */
-    public void testConstructor4() {
-        try {
-            Integer[] ints = new Integer[SIZE];
-            PriorityBlockingQueue q = new PriorityBlockingQueue(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);
-            PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints));
-            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);
-        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() {
-        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());
-    }
-
-    /**
-     * isEmpty is true before add, false after
-     */
-    public void testEmpty() {
-        PriorityBlockingQueue q = new PriorityBlockingQueue(2);
-        assertTrue(q.isEmpty());
-        assertEquals(NOCAP, q.remainingCapacity());
-        q.add(one);
-        assertFalse(q.isEmpty());
-        q.add(two);
-        q.remove();
-        q.remove();
-        assertTrue(q.isEmpty());
-    }
-
-    /**
-     * remainingCapacity does not change when elements added or removed,
-     * but size does
-     */
-    public void testRemainingCapacity() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(NOCAP, q.remainingCapacity());
-            assertEquals(SIZE-i, q.size());
-            q.remove();
-        }
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(NOCAP, q.remainingCapacity());
-            assertEquals(i, q.size());
-            q.add(new Integer(i));
-        }
-    }
-
-    /**
-     * offer(null) throws NPE
-     */
-    public void testOfferNull() {
-        try {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(1);
-            q.offer(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * add(null) throws NPE
-     */
-    public void testAddNull() {
-        try {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(1);
-            q.add(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Offer of comparable element succeeds
-     */
-    public void testOffer() {
-        PriorityBlockingQueue q = new PriorityBlockingQueue(1);
-        assertTrue(q.offer(zero));
-        assertTrue(q.offer(one));
-    }
-
-    /**
-     * Offer of non-Comparable throws CCE
-     */
-    public void testOfferNonComparable() {
-        try {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(1);
-            q.offer(new Object());
-            q.offer(new Object());
-            q.offer(new Object());
-            shouldThrow();
-        } catch (ClassCastException success) {}
-    }
-
-    /**
-     * add of comparable succeeds
-     */
-    public void testAdd() {
-        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
-        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 {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(1);
-            q.addAll(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * addAll(this) throws IAE
-     */
-    public void testAddAllSelf() {
-        try {
-            PriorityBlockingQueue q = populatedQueue(SIZE);
-            q.addAll(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * addAll of a collection with null elements throws NPE
-     */
-    public void testAddAll2() {
-        try {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(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 {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(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) {}
-    }
-
-    /**
-     * Queue contains all elements of successful addAll
-     */
-    public void testAddAll5() {
-        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());
-    }
-
-    /**
-     * put(null) throws NPE
-     */
-     public void testPutNull() {
-        try {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
-            q.put(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-     }
-
-    /**
-     * all elements successfully put are contained
-     */
-     public void testPut() {
-         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());
-    }
-
-    /**
-     * put doesn't block waiting for take
-     */
-    public void testPutWithTake() throws InterruptedException {
-        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
-        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() throws InterruptedException {
-        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
-        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() 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() throws InterruptedException {
-        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
-        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() 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();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-
-    /**
-     * poll succeeds unless empty
-     */
-    public void testPoll() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.poll());
-        }
-        assertNull(q.poll());
-    }
-
-    /**
-     * timed pool with zero timeout succeeds when non-empty, else times out
-     */
-    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() 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() 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();
-        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 PriorityBlockingQueue q = new PriorityBlockingQueue(2);
-        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();
-    }
-
-
-    /**
-     * peek returns next element, or null if empty
-     */
-    public void testPeek() {
-        PriorityBlockingQueue q = populatedQueue(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());
-    }
-
-    /**
-     * element returns next element, or throws NSEE if empty
-     */
-    public void testElement() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.element());
-            assertEquals(i, q.poll());
-        }
-        try {
-            q.element();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove removes next element, or throws NSEE if empty
-     */
-    public void testRemove() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.remove());
-        }
-        try {
-            q.remove();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove(x) removes x and returns true if present
-     */
-    public void testRemoveElement() {
-        PriorityBlockingQueue q = populatedQueue(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() {
-        PriorityBlockingQueue q = populatedQueue(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() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        q.clear();
-        assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
-        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() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        PriorityBlockingQueue p = new PriorityBlockingQueue(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() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        PriorityBlockingQueue p = populatedQueue(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) {
-            PriorityBlockingQueue q = populatedQueue(SIZE);
-            PriorityBlockingQueue p = populatedQueue(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 {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        Arrays.sort(o);
-        for (int i = 0; i < o.length; i++)
-            assertEquals(o[i], q.take());
-    }
-
-    /**
-     * toArray(a) contains all elements
-     */
-    public void testToArray2() throws InterruptedException {
-        PriorityBlockingQueue q = populatedQueue(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.take());
-    }
-
-    /**
-     * toArray(null) throws NPE
-     */
-    public void testToArray_BadArg() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        try {
-            Object o[] = q.toArray(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * toArray with incompatible array type throws CCE
-     */
-    public void testToArray1_BadArg() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        try {
-            Object o[] = q.toArray(new String[10]);
-            shouldThrow();
-        } catch (ArrayStoreException success) {}
-    }
-
-    /**
-     * iterator iterates through all elements
-     */
-    public void testIterator() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        int i = 0;
-        Iterator it = q.iterator();
-        while (it.hasNext()) {
-            assertTrue(q.contains(it.next()));
-            ++i;
-        }
-        assertEquals(i, SIZE);
-    }
-
-    /**
-     * iterator.remove removes current element
-     */
-    public void testIteratorRemove () {
-        final PriorityBlockingQueue q = new PriorityBlockingQueue(3);
-        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() {
-        PriorityBlockingQueue q = populatedQueue(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 testPollInExecutor() {
-        final PriorityBlockingQueue q = new PriorityBlockingQueue(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 queue has same elements
-     */
-    public void testSerialization() throws Exception {
-        PriorityBlockingQueue q = populatedQueue(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));
-        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) {}
-    }
-
-    /**
-     * drainTo(this) throws IAE
-     */
-    public void testDrainToSelf() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(q);
-            shouldThrow();
-        } 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)
-            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 queue
-     */
-    public void testDrainToWithActivePut() throws InterruptedException {
-        final PriorityBlockingQueue q = populatedQueue(SIZE);
-        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) {}
-    }
-
-    /**
-     * drainTo(this, n) throws IAE
-     */
-    public void testDrainToSelfN() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(q, 0);
-            shouldThrow();
-        } 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++)
-                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/PriorityQueueTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/PriorityQueueTest.java
deleted file mode 100755
index 12ddef4..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/PriorityQueueTest.java
+++ /dev/null
@@ -1,485 +0,0 @@
-/*
- * 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 java.io.*;
-
-public class PriorityQueueTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(PriorityQueueTest.class);
-    }
-
-    static class MyReverseComparator implements Comparator {
-        public int compare(Object x, Object y) {
-            return ((Comparable)y).compareTo(x);
-        }
-    }
-
-    /**
-     * Create a queue of given size containing consecutive
-     * Integers 0 ... n.
-     */
-    private PriorityQueue populatedQueue(int n) {
-        PriorityQueue q = new PriorityQueue(n);
-        assertTrue(q.isEmpty());
-        for (int i = n-1; i >= 0; i-=2)
-            assertTrue(q.offer(new Integer(i)));
-        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
-     */
-    public void testConstructor1() {
-        assertEquals(0, new PriorityQueue(SIZE).size());
-    }
-
-    /**
-     * Constructor throws IAE if capacity argument nonpositive
-     */
-    public void testConstructor2() {
-        try {
-            PriorityQueue q = new PriorityQueue(0);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * Initializing from null Collection throws NPE
-     */
-    public void testConstructor3() {
-        try {
-            PriorityQueue q = new PriorityQueue((Collection)null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Initializing from Collection of null elements throws NPE
-     */
-    public void testConstructor4() {
-        try {
-            Integer[] ints = new Integer[SIZE];
-            PriorityQueue q = new PriorityQueue(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);
-            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
-            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);
-        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() {
-        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());
-    }
-
-    /**
-     * isEmpty is true before add, false after
-     */
-    public void testEmpty() {
-        PriorityQueue q = new PriorityQueue(2);
-        assertTrue(q.isEmpty());
-        q.add(new Integer(1));
-        assertFalse(q.isEmpty());
-        q.add(new Integer(2));
-        q.remove();
-        q.remove();
-        assertTrue(q.isEmpty());
-    }
-
-    /**
-     * size changes when elements added and removed
-     */
-    public void testSize() {
-        PriorityQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(SIZE-i, q.size());
-            q.remove();
-        }
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.size());
-            q.add(new Integer(i));
-        }
-    }
-
-    /**
-     * offer(null) throws NPE
-     */
-    public void testOfferNull() {
-        try {
-            PriorityQueue q = new PriorityQueue(1);
-            q.offer(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * add(null) throws NPE
-     */
-    public void testAddNull() {
-        try {
-            PriorityQueue q = new PriorityQueue(1);
-            q.add(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * Offer of comparable element succeeds
-     */
-    public void testOffer() {
-        PriorityQueue q = new PriorityQueue(1);
-        assertTrue(q.offer(zero));
-        assertTrue(q.offer(one));
-    }
-
-    /**
-     * Offer of non-Comparable throws CCE
-     */
-    public void testOfferNonComparable() {
-        try {
-            PriorityQueue q = new PriorityQueue(1);
-            q.offer(new Object());
-            q.offer(new Object());
-            q.offer(new Object());
-            shouldThrow();
-        } catch (ClassCastException success) {}
-    }
-
-    /**
-     * add of comparable succeeds
-     */
-    public void testAdd() {
-        PriorityQueue q = new PriorityQueue(SIZE);
-        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 {
-            PriorityQueue q = new PriorityQueue(1);
-            q.addAll(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-    /**
-     * addAll of a collection with null elements throws NPE
-     */
-    public void testAddAll2() {
-        try {
-            PriorityQueue q = new PriorityQueue(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 {
-            PriorityQueue q = new PriorityQueue(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) {}
-    }
-
-    /**
-     * Queue 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);
-        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());
-    }
-
-    /**
-     * poll succeeds unless empty
-     */
-    public void testPoll() {
-        PriorityQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.poll());
-        }
-        assertNull(q.poll());
-    }
-
-    /**
-     * peek returns next element, or null if empty
-     */
-    public void testPeek() {
-        PriorityQueue q = populatedQueue(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());
-    }
-
-    /**
-     * element returns next element, or throws NSEE if empty
-     */
-    public void testElement() {
-        PriorityQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.element());
-            assertEquals(i, q.poll());
-        }
-        try {
-            q.element();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove removes next element, or throws NSEE if empty
-     */
-    public void testRemove() {
-        PriorityQueue q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.remove());
-        }
-        try {
-            q.remove();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove(x) removes x and returns true if present
-     */
-    public void testRemoveElement() {
-        PriorityQueue q = populatedQueue(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() {
-        PriorityQueue q = populatedQueue(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() {
-        PriorityQueue q = populatedQueue(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() {
-        PriorityQueue q = populatedQueue(SIZE);
-        PriorityQueue p = new PriorityQueue(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() {
-        PriorityQueue q = populatedQueue(SIZE);
-        PriorityQueue p = populatedQueue(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) {
-            PriorityQueue q = populatedQueue(SIZE);
-            PriorityQueue p = populatedQueue(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() {
-        PriorityQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        Arrays.sort(o);
-        for (int i = 0; i < o.length; i++)
-            assertEquals(o[i], q.poll());
-    }
-
-    /**
-     * toArray(a) contains all elements
-     */
-    public void testToArray2() {
-        PriorityQueue q = populatedQueue(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.poll());
-    }
-
-    /**
-     * iterator iterates through all elements
-     */
-    public void testIterator() {
-        PriorityQueue q = populatedQueue(SIZE);
-        int i = 0;
-        Iterator it = q.iterator();
-        while (it.hasNext()) {
-            assertTrue(q.contains(it.next()));
-            ++i;
-        }
-        assertEquals(i, SIZE);
-    }
-
-    /**
-     * iterator.remove removes current element
-     */
-    public void testIteratorRemove () {
-        final PriorityQueue q = new PriorityQueue(3);
-        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() {
-        PriorityQueue q = populatedQueue(SIZE);
-        String s = q.toString();
-        for (int i = 0; i < SIZE; ++i) {
-            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
-        }
-    }
-
-    /**
-     * A deserialized serialized queue has same elements
-     */
-    public void testSerialization() throws Exception {
-        PriorityQueue q = populatedQueue(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));
-        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
deleted file mode 100755
index d6b434e..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ReentrantLockTest.java
+++ /dev/null
@@ -1,911 +0,0 @@
-/*
- * 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.concurrent.locks.*;
-import java.util.concurrent.*;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.util.*;
-import java.io.*;
-
-public class ReentrantLockTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(ReentrantLockTest.class);
-    }
-
-    /**
-     * A runnable calling lockInterruptibly
-     */
-    class InterruptibleLockRunnable extends CheckedRunnable {
-        final ReentrantLock lock;
-        InterruptibleLockRunnable(ReentrantLock l) { lock = l; }
-        public void realRun() throws InterruptedException {
-            lock.lockInterruptibly();
-        }
-    }
-
-
-    /**
-     * A runnable calling lockInterruptibly that expects to be
-     * interrupted
-     */
-    class InterruptedLockRunnable extends CheckedInterruptedRunnable {
-        final ReentrantLock lock;
-        InterruptedLockRunnable(ReentrantLock l) { lock = l; }
-        public void realRun() throws InterruptedException {
-            lock.lockInterruptibly();
-        }
-    }
-
-    /**
-     * Subclass to expose protected methods
-     */
-    static class PublicReentrantLock extends ReentrantLock {
-        PublicReentrantLock() { super(); }
-        public Collection<Thread> getQueuedThreads() {
-            return super.getQueuedThreads();
-        }
-        public Collection<Thread> getWaitingThreads(Condition c) {
-            return super.getWaitingThreads(c);
-        }
-    }
-
-    /**
-     * Constructor sets given fairness
-     */
-    public void testConstructor() {
-        assertFalse(new ReentrantLock().isFair());
-        assertFalse(new ReentrantLock(false).isFair());
-        assertTrue(new ReentrantLock(true).isFair());
-    }
-
-    /**
-     * locking an unlocked lock succeeds
-     */
-    public void testLock() {
-        ReentrantLock rl = new ReentrantLock();
-        rl.lock();
-        assertTrue(rl.isLocked());
-        rl.unlock();
-        assertFalse(rl.isLocked());
-    }
-
-    /**
-     * locking an unlocked fair lock succeeds
-     */
-    public void testFairLock() {
-        ReentrantLock rl = new ReentrantLock(true);
-        rl.lock();
-        assertTrue(rl.isLocked());
-        rl.unlock();
-    }
-
-    /**
-     * Unlocking an unlocked lock throws IllegalMonitorStateException
-     */
-    public void testUnlock_IllegalMonitorStateException() {
-        ReentrantLock rl = new ReentrantLock();
-        try {
-            rl.unlock();
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-    /**
-     * tryLock on an unlocked lock succeeds
-     */
-    public void testTryLock() {
-        ReentrantLock rl = new ReentrantLock();
-        assertTrue(rl.tryLock());
-        assertTrue(rl.isLocked());
-        rl.unlock();
-    }
-
-
-    /**
-     * hasQueuedThreads reports whether there are waiting threads
-     */
-    public void testhasQueuedThreads() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock(true);
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        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();
-    }
-
-    /**
-     * hasQueuedThread(null) throws NPE
-     */
-    public void testHasQueuedThreadNPE() {
-        final ReentrantLock sync = new ReentrantLock();
-        try {
-            sync.hasQueuedThread(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * hasQueuedThread reports whether a thread is queued.
-     */
-    public void testHasQueuedThread() throws InterruptedException {
-        final ReentrantLock sync = new ReentrantLock();
-        Thread t1 = new Thread(new InterruptedLockRunnable(sync));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
-        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() throws InterruptedException {
-        final PublicReentrantLock lock = new PublicReentrantLock();
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        lock.lock();
-        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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        lock.lock();
-        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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        lock.lock();
-        Thread t = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                threadAssertFalse(lock.tryLock(1, MILLISECONDS));
-            }});
-
-        t.start();
-        t.join();
-        lock.unlock();
-    }
-
-    /**
-     * getHoldCount returns number of recursive holds
-     */
-    public void testGetHoldCount() {
-        ReentrantLock lock = new ReentrantLock();
-        for (int i = 1; i <= SIZE; i++) {
-            lock.lock();
-            assertEquals(i, lock.getHoldCount());
-        }
-        for (int i = SIZE; i > 0; i--) {
-            lock.unlock();
-            assertEquals(i-1, lock.getHoldCount());
-        }
-    }
-
-
-    /**
-     * isLocked is true when locked and false when not
-     */
-    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 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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        lock.lock();
-        Thread t = new Thread(new InterruptedLockRunnable(lock));
-        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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        lock.lockInterruptibly();
-        Thread t = new Thread(new InterruptedLockRunnable(lock));
-        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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        try {
-            c.await();
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-    /**
-     * Calling signal without holding lock throws IllegalMonitorStateException
-     */
-    public void testSignal_IllegalMonitor() {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        try {
-            c.signal();
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-    /**
-     * awaitNanos without a signal times out
-     */
-    public void testAwaitNanos_Timeout() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        lock.lock();
-        long t = c.awaitNanos(100);
-        assertTrue(t <= 0);
-        lock.unlock();
-    }
-
-    /**
-     *  timed await without a signal times out
-     */
-    public void testAwait_Timeout() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        lock.lock();
-        assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
-        lock.unlock();
-    }
-
-    /**
-     * awaitUntil without a signal times out
-     */
-    public void testAwaitUntil_Timeout() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        Thread t = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                lock.lock();
-                c.await();
-                lock.unlock();
-            }});
-
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        lock.lock();
-        c.signal();
-        lock.unlock();
-        t.join(SHORT_DELAY_MS);
-        assertFalse(t.isAlive());
-    }
-
-    /**
-     * hasWaiters throws NPE if null
-     */
-    public void testHasWaitersNPE() {
-        final ReentrantLock lock = new ReentrantLock();
-        try {
-            lock.hasWaiters(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * getWaitQueueLength throws NPE if null
-     */
-    public void testGetWaitQueueLengthNPE() {
-        final ReentrantLock lock = new ReentrantLock();
-        try {
-            lock.getWaitQueueLength(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * getWaitingThreads throws NPE if null
-     */
-    public void testGetWaitingThreadsNPE() {
-        final PublicReentrantLock lock = new PublicReentrantLock();
-        try {
-            lock.getWaitingThreads(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * hasWaiters throws IAE if not owned
-     */
-    public void testHasWaitersIAE() {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        final ReentrantLock lock2 = new ReentrantLock();
-        try {
-            lock2.hasWaiters(c);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * hasWaiters throws IMSE if not locked
-     */
-    public void testHasWaitersIMSE() {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        try {
-            lock.hasWaiters(c);
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-
-    /**
-     * getWaitQueueLength throws IAE if not owned
-     */
-    public void testGetWaitQueueLengthIAE() {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        final ReentrantLock lock2 = new ReentrantLock();
-        try {
-            lock2.getWaitQueueLength(c);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * getWaitQueueLength throws IMSE if not locked
-     */
-    public void testGetWaitQueueLengthIMSE() {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        try {
-            lock.getWaitQueueLength(c);
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-
-    /**
-     * getWaitingThreads throws IAE if not owned
-     */
-    public void testGetWaitingThreadsIAE() {
-        final PublicReentrantLock lock = new PublicReentrantLock();
-        final Condition c = lock.newCondition();
-        final PublicReentrantLock lock2 = new PublicReentrantLock();
-        try {
-            lock2.getWaitingThreads(c);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * getWaitingThreads throws IMSE if not locked
-     */
-    public void testGetWaitingThreadsIMSE() {
-        final PublicReentrantLock lock = new PublicReentrantLock();
-        final Condition c = lock.newCondition();
-        try {
-            lock.getWaitingThreads(c);
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-
-    /**
-     * hasWaiters returns true when a thread is waiting, else false
-     */
-    public void testHasWaiters() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        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();
-            }});
-
-        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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        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();
-            }});
-
-        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() throws InterruptedException {
-        final PublicReentrantLock lock = new PublicReentrantLock();
-        final Condition c = lock.newCondition();
-        Thread t1 = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                lock.lock();
-                threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
-                c.await();
-                lock.unlock();
-            }});
-
-        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 UninterruptibleThread extends Thread {
-        private ReentrantLock lock;
-        private Condition c;
-
-        public volatile boolean canAwake = false;
-        public volatile boolean interrupted = false;
-        public volatile boolean lockStarted = false;
-
-        public UninterruptibleThread(ReentrantLock lock, Condition c) {
-            this.lock = lock;
-            this.c = c;
-        }
-
-        public synchronized void run() {
-            lock.lock();
-            lockStarted = true;
-
-            while (!canAwake) {
-                c.awaitUninterruptibly();
-            }
-
-            interrupted = isInterrupted();
-            lock.unlock();
-        }
-    }
-
-    /**
-     * awaitUninterruptibly doesn't abort on interrupt
-     */
-    public void testAwaitUninterruptibly() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        UninterruptibleThread thread = new UninterruptibleThread(lock, c);
-
-        thread.start();
-
-        while (!thread.lockStarted) {
-            Thread.sleep(100);
-        }
-
-        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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                lock.lock();
-                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 ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                lock.lock();
-                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 ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        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));
-            }});
-
-        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 ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        Thread t1 = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                lock.lock();
-                c.await();
-                lock.unlock();
-            }});
-
-        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() throws InterruptedException {
-        final ReentrantLock lock = new ReentrantLock();
-        final Condition c = lock.newCondition();
-        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();
-            }});
-
-        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() throws Exception {
-        ReentrantLock l = new ReentrantLock();
-        l.lock();
-        l.unlock();
-
-        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();
-    }
-
-    /**
-     * toString indicates current lock state
-     */
-    public void testToString() {
-        ReentrantLock lock = new ReentrantLock();
-        String us = lock.toString();
-        assertTrue(us.indexOf("Unlocked") >= 0);
-        lock.lock();
-        String ls = lock.toString();
-        assertTrue(ls.indexOf("Locked") >= 0);
-    }
-
-}
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
deleted file mode 100644
index eb20255..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ReentrantReadWriteLockTest.java
+++ /dev/null
@@ -1,1371 +0,0 @@
-/*
- * 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.concurrent.locks.*;
-import java.util.concurrent.*;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.io.*;
-import java.util.*;
-
-public class ReentrantReadWriteLockTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(ReentrantReadWriteLockTest.class);
-    }
-
-    /**
-     * A runnable calling lockInterruptibly
-     */
-    class InterruptibleLockRunnable extends CheckedRunnable {
-        final ReentrantReadWriteLock lock;
-        InterruptibleLockRunnable(ReentrantReadWriteLock l) { lock = l; }
-        public void realRun() throws InterruptedException {
-            lock.writeLock().lockInterruptibly();
-        }
-    }
-
-
-    /**
-     * A runnable calling lockInterruptibly that expects to be
-     * interrupted
-     */
-    class InterruptedLockRunnable extends CheckedInterruptedRunnable {
-        final ReentrantReadWriteLock lock;
-        InterruptedLockRunnable(ReentrantReadWriteLock l) { lock = l; }
-        public void realRun() throws InterruptedException {
-            lock.writeLock().lockInterruptibly();
-        }
-    }
-
-    /**
-     * Subclass to expose protected methods
-     */
-    static class PublicReentrantReadWriteLock extends ReentrantReadWriteLock {
-        PublicReentrantReadWriteLock() { super(); }
-        public Collection<Thread> getQueuedThreads() {
-            return super.getQueuedThreads();
-        }
-        public Collection<Thread> getWaitingThreads(Condition c) {
-            return super.getWaitingThreads(c);
-        }
-    }
-
-    /**
-     * Constructor sets given fairness, and is in unlocked state
-     */
-    public void testConstructor() {
-        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
-        assertFalse(rl.isFair());
-        assertFalse(rl.isWriteLocked());
-        assertEquals(0, rl.getReadLockCount());
-        ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
-        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());
-    }
-
-    /**
-     * write-locking and read-locking an unlocked lock succeed
-     */
-    public void testLock() {
-        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
-        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());
-        assertFalse(rl.isWriteLockedByCurrentThread());
-        assertEquals(1, rl.getReadLockCount());
-        rl.readLock().unlock();
-        assertFalse(rl.isWriteLocked());
-        assertFalse(rl.isWriteLockedByCurrentThread());
-        assertEquals(0, rl.getReadLockCount());
-    }
-
-
-    /**
-     * locking an unlocked fair lock succeeds
-     */
-    public void testFairLock() {
-        ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
-        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());
-        assertFalse(rl.isWriteLockedByCurrentThread());
-        assertEquals(1, rl.getReadLockCount());
-        rl.readLock().unlock();
-        assertFalse(rl.isWriteLocked());
-        assertFalse(rl.isWriteLockedByCurrentThread());
-        assertEquals(0, rl.getReadLockCount());
-    }
-
-    /**
-     * 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());
-        }
-    }
-
-    /**
-     * 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());
-        }
-    }
-
-
-    /**
-     * write-unlocking an unlocked lock throws IllegalMonitorStateException
-     */
-    public void testUnlock_IllegalMonitorStateException() {
-        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
-        try {
-            rl.writeLock().unlock();
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-
-    /**
-     * write-lockInterruptibly is interruptible
-     */
-    public void testWriteLockInterruptibly_Interrupted() throws Exception {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        lock.writeLock().lock();
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        lock.writeLock().lock();
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        lock.writeLock().lock();
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        lock.writeLock().lock();
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        lock.writeLock().lock();
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        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();
-    }
-
-    /**
-     * A writelock succeeds after reading threads unlock
-     */
-    public void testWriteAfterMultipleReadLocks() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        lock.readLock().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.writeLock().lock();
-                lock.writeLock().unlock();
-            }});
-
-        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() 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();
-        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();
-        assertTrue(lock.readLock().tryLock());
-        lock.readLock().unlock();
-        lock.writeLock().unlock();
-    }
-
-    /**
-     * Read lock succeeds if write locked by current thread even if
-     * other threads are waiting for readlock
-     */
-    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() 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();
-            }});
-
-        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());
-    }
-
-
-    /**
-     *  Write lock succeeds if write locked by current thread even if
-     * other threads are waiting for writelock
-     */
-    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();
-            }});
-
-        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());
-    }
-
-
-    /**
-     * Fair Read trylock succeeds if write locked by current thread
-     */
-    public void testReadHoldingWriteLockFair() {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
-        lock.writeLock().lock();
-        assertTrue(lock.readLock().tryLock());
-        lock.readLock().unlock();
-        lock.writeLock().unlock();
-    }
-
-    /**
-     * Fair Read lock succeeds if write locked by current thread even if
-     * other threads are waiting for readlock
-     */
-    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());
-    }
-
-
-    /**
-     * Fair Read lock succeeds if write locked by current thread even if
-     * other threads are waiting for writelock
-     */
-    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();
-            }});
-
-        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());
-    }
-
-
-    /**
-     * Fair Write lock succeeds if write locked by current thread even if
-     * other threads are waiting for writelock
-     */
-    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();
-            }});
-
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        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();
-    }
-
-
-
-    /**
-     * write tryLock fails when readlocked
-     */
-    public void testWriteTryLockWhenReadLocked() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        lock.readLock().lock();
-        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() 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();
-    }
-
-
-
-    /**
-     * Fair write tryLock fails when readlocked
-     */
-    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();
-    }
-
-
-
-    /**
-     * write timed tryLock times out if locked
-     */
-    public void testWriteTryLock_Timeout() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        lock.writeLock().lock();
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        lock.writeLock().lock();
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        try {
-            c.await();
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-    /**
-     * Calling signal without holding lock throws IllegalMonitorStateException
-     */
-    public void testSignal_IllegalMonitor() {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        try {
-            c.signal();
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-    /**
-     * awaitNanos without a signal times out
-     */
-    public void testAwaitNanos_Timeout() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        lock.writeLock().lock();
-        assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
-        lock.writeLock().unlock();
-    }
-
-    /**
-     * awaitUntil without a signal times out
-     */
-    public void testAwaitUntil_Timeout() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        Thread t = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                lock.writeLock().lock();
-                c.await();
-                lock.writeLock().unlock();
-            }});
-
-        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 */
-    class UninterruptableThread extends Thread {
-        private Lock lock;
-        private Condition c;
-
-        public volatile boolean canAwake = false;
-        public volatile boolean interrupted = false;
-        public volatile boolean lockStarted = false;
-
-        public UninterruptableThread(Lock lock, Condition c) {
-            this.lock = lock;
-            this.c = c;
-        }
-
-        public synchronized void run() {
-            lock.lock();
-            lockStarted = true;
-
-            while (!canAwake) {
-                c.awaitUninterruptibly();
-            }
-
-            interrupted = isInterrupted();
-            lock.unlock();
-        }
-    }
-
-    /**
-     * awaitUninterruptibly doesn't abort on interrupt
-     */
-    public void testAwaitUninterruptibly() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        UninterruptableThread thread = new UninterruptableThread(lock.writeLock(), c);
-
-        thread.start();
-
-        while (!thread.lockStarted) {
-            Thread.sleep(100);
-        }
-
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                lock.writeLock().lock();
-                c.await();
-                lock.writeLock().unlock();
-            }});
-
-        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 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                lock.writeLock().lock();
-                c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
-                lock.writeLock().unlock();
-            }});
-
-        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 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        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();
-            }});
-
-        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 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        Thread t1 = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                lock.writeLock().lock();
-                c.await();
-                lock.writeLock().unlock();
-            }});
-
-        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() throws Exception {
-        ReentrantReadWriteLock l = new ReentrantReadWriteLock();
-        l.readLock().lock();
-        l.readLock().unlock();
-
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        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();
-    }
-
-    /**
-     * hasQueuedThread(null) throws NPE
-     */
-    public void testHasQueuedThreadNPE() {
-        final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
-        try {
-            sync.hasQueuedThread(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * hasQueuedThread reports whether a thread is queued.
-     */
-    public void testHasQueuedThread() throws InterruptedException {
-        final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
-        Thread t1 = new Thread(new InterruptedLockRunnable(sync));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        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() throws InterruptedException {
-        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        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();
-    }
-
-    /**
-     * hasWaiters throws NPE if null
-     */
-    public void testHasWaitersNPE() {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        try {
-            lock.hasWaiters(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * getWaitQueueLength throws NPE if null
-     */
-    public void testGetWaitQueueLengthNPE() {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        try {
-            lock.getWaitQueueLength(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * getWaitingThreads throws NPE if null
-     */
-    public void testGetWaitingThreadsNPE() {
-        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
-        try {
-            lock.getWaitingThreads(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * hasWaiters throws IAE if not owned
-     */
-    public void testHasWaitersIAE() {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
-        try {
-            lock2.hasWaiters(c);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * hasWaiters throws IMSE if not locked
-     */
-    public void testHasWaitersIMSE() {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        try {
-            lock.hasWaiters(c);
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-
-    /**
-     * getWaitQueueLength throws IAE if not owned
-     */
-    public void testGetWaitQueueLengthIAE() {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
-        try {
-            lock2.getWaitQueueLength(c);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * getWaitQueueLength throws IMSE if not locked
-     */
-    public void testGetWaitQueueLengthIMSE() {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        try {
-            lock.getWaitQueueLength(c);
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-
-    /**
-     * getWaitingThreads throws IAE if not owned
-     */
-    public void testGetWaitingThreadsIAE() {
-        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
-        try {
-            lock2.getWaitingThreads(c);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * getWaitingThreads throws IMSE if not locked
-     */
-    public void testGetWaitingThreadsIMSE() {
-        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        try {
-            lock.getWaitingThreads(c);
-            shouldThrow();
-        } catch (IllegalMonitorStateException success) {}
-    }
-
-
-    /**
-     * hasWaiters returns true when a thread is waiting, else false
-     */
-    public void testHasWaiters() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        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();
-            }});
-
-        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() throws InterruptedException {
-        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        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();
-            }});
-
-        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() throws InterruptedException {
-        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
-        final Condition c = lock.writeLock().newCondition();
-        Thread t1 = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                lock.writeLock().lock();
-                threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
-                c.await();
-                lock.writeLock().unlock();
-            }});
-
-        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());
-    }
-
-    /**
-     * toString indicates current lock state
-     */
-    public void testToString() {
-        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        String us = lock.toString();
-        assertTrue(us.indexOf("Write locks = 0") >= 0);
-        assertTrue(us.indexOf("Read locks = 0") >= 0);
-        lock.writeLock().lock();
-        String ws = lock.toString();
-        assertTrue(ws.indexOf("Write locks = 1") >= 0);
-        assertTrue(ws.indexOf("Read locks = 0") >= 0);
-        lock.writeLock().unlock();
-        lock.readLock().lock();
-        lock.readLock().lock();
-        String rs = lock.toString();
-        assertTrue(rs.indexOf("Write locks = 0") >= 0);
-        assertTrue(rs.indexOf("Read locks = 2") >= 0);
-    }
-
-    /**
-     * readLock.toString indicates current lock state
-     */
-    public void testReadLockToString() {
-        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        String us = lock.readLock().toString();
-        assertTrue(us.indexOf("Read locks = 0") >= 0);
-        lock.readLock().lock();
-        lock.readLock().lock();
-        String rs = lock.readLock().toString();
-        assertTrue(rs.indexOf("Read locks = 2") >= 0);
-    }
-
-    /**
-     * writeLock.toString indicates current lock state
-     */
-    public void testWriteLockToString() {
-        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        String us = lock.writeLock().toString();
-        assertTrue(us.indexOf("Unlocked") >= 0);
-        lock.writeLock().lock();
-        String ls = lock.writeLock().toString();
-        assertTrue(ls.indexOf("Locked") >= 0);
-    }
-
-}
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
deleted file mode 100644
index 21f4ced..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ScheduledExecutorSubclassTest.java
+++ /dev/null
@@ -1,1060 +0,0 @@
-/*
- * 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
deleted file mode 100755
index ff1796e..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ScheduledExecutorTest.java
+++ /dev/null
@@ -1,1012 +0,0 @@
-/*
- * 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.atomic.*;
-
-public class ScheduledExecutorTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(ScheduledExecutorTest.class);
-    }
-
-
-    /**
-     * execute successfully executes a runnable
-     */
-    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() 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() 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() 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 {
-        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();
-        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() 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() 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() throws InterruptedException {
-        ScheduledThreadPoolExecutor se = null;
-        try {
-            se = new ScheduledThreadPoolExecutor(1);
-            se.execute(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-
-        joinPool(se);
-    }
-
-    /**
-     * schedule (null) throws NPE
-     */
-    public void testScheduleNull() throws InterruptedException {
-        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(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() throws InterruptedException {
-        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(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() throws InterruptedException {
-        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(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() throws InterruptedException {
-         ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(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() throws InterruptedException {
-        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(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() throws InterruptedException {
-        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(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 {
-        ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(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 {
-        ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(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() 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() throws InterruptedException {
-        ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(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() 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() throws InterruptedException {
-        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(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() 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() throws InterruptedException {
-        ThreadFactory tf = new SimpleThreadFactory();
-        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
-        p.setThreadFactory(tf);
-        assertSame(tf, p.getThreadFactory());
-        joinPool(p);
-    }
-
-    /**
-     * setThreadFactory(null) throws NPE
-     */
-    public void testSetThreadFactoryNull() throws InterruptedException {
-        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
-        try {
-            p.setThreadFactory(null);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        } finally {
-            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; }
-        }
-        assertTrue(p1.isShutdown());
-    }
-
-
-    /**
-     *   isTerminated is false before termination, true after
-     */
-    public void testIsTerminated() throws InterruptedException {
-        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(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 {
-        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(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 {
-        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(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 {
-        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(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 {
-        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, 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() throws InterruptedException {
-        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(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 {
-        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());
-        }
-        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 {
-        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());
-    }
-
-
-    /**
-     * If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false,
-     * periodic tasks are not cancelled at shutdown
-     */
-    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() throws InterruptedException {
-        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 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 {
-            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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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 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 {
-            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 ScheduledThreadPoolExecutor(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 ScheduledThreadPoolExecutor(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/SemaphoreTest.java b/concurrent/src/test/java/tests/api/java/util/concurrent/SemaphoreTest.java
deleted file mode 100755
index c27893c..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/SemaphoreTest.java
+++ /dev/null
@@ -1,765 +0,0 @@
-/*
- * 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.io.*;
-
-public class SemaphoreTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(SemaphoreTest.class);
-    }
-
-    /**
-     * Subclass to expose protected methods
-     */
-    static class PublicSemaphore extends Semaphore {
-        PublicSemaphore(int p, boolean f) { super(p, f); }
-        public Collection<Thread> getQueuedThreads() {
-            return super.getQueuedThreads();
-        }
-        public void reducePermits(int p) {
-            super.reducePermits(p);
-        }
-    }
-
-    /**
-     * A runnable calling acquire
-     */
-    class InterruptibleLockRunnable extends CheckedRunnable {
-        final Semaphore lock;
-        InterruptibleLockRunnable(Semaphore l) { lock = l; }
-        public void realRun() {
-            try {
-                lock.acquire();
-            }
-            catch (InterruptedException ignored) {}
-        }
-    }
-
-
-    /**
-     * A runnable calling acquire that expects to be interrupted
-     */
-    class InterruptedLockRunnable extends CheckedInterruptedRunnable {
-        final Semaphore lock;
-        InterruptedLockRunnable(Semaphore l) { lock = l; }
-        public void realRun() throws InterruptedException {
-            lock.acquire();
-        }
-    }
-
-    /**
-     * Zero, negative, and positive initial values are allowed in constructor
-     */
-    public void testConstructor() {
-        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() {
-        for (int permits : new int[] { -1, 0, 1 }) {
-            Semaphore s = new Semaphore(permits);
-            assertEquals(permits, s.availablePermits());
-            assertFalse(s.isFair());
-        }
-    }
-
-    /**
-     * tryAcquire succeeds when sufficient permits, else fails
-     */
-    public void testTryAcquireInSameThread() {
-        Semaphore s = new Semaphore(2, false);
-        assertEquals(2, s.availablePermits());
-        assertTrue(s.tryAcquire());
-        assertTrue(s.tryAcquire());
-        assertEquals(0, s.availablePermits());
-        assertFalse(s.tryAcquire());
-    }
-
-    /**
-     * Acquire and release of semaphore succeed if initially available
-     */
-    public void testAcquireReleaseInSameThread()
-        throws InterruptedException {
-        Semaphore s = new Semaphore(1, false);
-        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()
-        throws InterruptedException {
-        Semaphore s = new Semaphore(1, false);
-        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()
-        throws InterruptedException {
-        Semaphore s = new Semaphore(1, false);
-        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()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(0, false);
-        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()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(0, false);
-        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()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(1, false);
-        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()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(0, false);
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                s.acquire();
-            }});
-
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     *  A waiting timed acquire blocks interruptibly
-     */
-    public void testTryAcquire_InterruptedException()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(0, false);
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                s.tryAcquire(MEDIUM_DELAY_MS, MILLISECONDS);
-            }});
-
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     * hasQueuedThreads reports whether there are waiting threads
-     */
-    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));
-        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() throws InterruptedException {
-        final Semaphore lock = new Semaphore(1, false);
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        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() throws InterruptedException {
-        final PublicSemaphore lock = new PublicSemaphore(1, false);
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        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
-     */
-    public void testDrainPermits() {
-        Semaphore s = new Semaphore(0, false);
-        assertEquals(0, s.availablePermits());
-        assertEquals(0, s.drainPermits());
-        s.release(10);
-        assertEquals(10, s.availablePermits());
-        assertEquals(10, s.drainPermits());
-        assertEquals(0, s.availablePermits());
-        assertEquals(0, s.drainPermits());
-    }
-
-    /**
-     * reducePermits reduces number of permits
-     */
-    public void testReducePermits() {
-        PublicSemaphore s = new PublicSemaphore(10, false);
-        assertEquals(10, s.availablePermits());
-        s.reducePermits(1);
-        assertEquals(9, s.availablePermits());
-        s.reducePermits(10);
-        assertEquals(-1, s.availablePermits());
-    }
-
-    /**
-     * a deserialized serialized semaphore has same number of permits
-     */
-    public void testSerialization() throws Exception {
-        Semaphore l = new Semaphore(3, false);
-        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();
-    }
-
-
-    /**
-     * Zero, negative, and positive initial values are allowed in constructor
-     */
-    public void testConstructor_fair() {
-        Semaphore s0 = new Semaphore(0, true);
-        assertEquals(0, s0.availablePermits());
-        assertTrue(s0.isFair());
-        Semaphore s1 = new Semaphore(-1, true);
-        assertEquals(-1, s1.availablePermits());
-        Semaphore s2 = new Semaphore(-1, true);
-        assertEquals(-1, s2.availablePermits());
-    }
-
-    /**
-     * tryAcquire succeeds when sufficient permits, else fails
-     */
-    public void testTryAcquireInSameThread_fair() {
-        Semaphore s = new Semaphore(2, true);
-        assertEquals(2, s.availablePermits());
-        assertTrue(s.tryAcquire());
-        assertTrue(s.tryAcquire());
-        assertEquals(0, s.availablePermits());
-        assertFalse(s.tryAcquire());
-    }
-
-    /**
-     * tryAcquire(n) succeeds when sufficient permits, else fails
-     */
-    public void testTryAcquireNInSameThread_fair() {
-        Semaphore s = new Semaphore(2, true);
-        assertEquals(2, s.availablePermits());
-        assertTrue(s.tryAcquire(2));
-        assertEquals(0, s.availablePermits());
-        assertFalse(s.tryAcquire());
-    }
-
-    /**
-     * Acquire and release of semaphore succeed if initially available
-     */
-    public void testAcquireReleaseInSameThread_fair()
-        throws InterruptedException {
-        Semaphore s = new Semaphore(1, true);
-        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()
-        throws InterruptedException {
-        Semaphore s = new Semaphore(1, true);
-        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());
-    }
-
-    /**
-     * Acquire(n) and release(n) of semaphore succeed if initially available
-     */
-    public void testAcquireUninterruptiblyReleaseNInSameThread_fair() {
-        Semaphore s = new Semaphore(1, true);
-        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()
-        throws InterruptedException {
-        Semaphore s = new Semaphore(1, true);
-        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()
-        throws InterruptedException {
-        Semaphore s = new Semaphore(1, true);
-        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()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(0, true);
-        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()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(0, true);
-        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()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(0, true);
-        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()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(1, true);
-        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();
-        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()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(2, true);
-        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();
-        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()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(0, true);
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                s.acquire();
-            }});
-
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     * A waiting acquire(n) blocks interruptibly
-     */
-    public void testAcquireN_InterruptedException_fair()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(2, true);
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                s.acquire(3);
-            }});
-
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     *  A waiting tryAcquire blocks interruptibly
-     */
-    public void testTryAcquire_InterruptedException_fair()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(0, true);
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                s.tryAcquire(MEDIUM_DELAY_MS, MILLISECONDS);
-            }});
-
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     *  A waiting tryAcquire(n) blocks interruptibly
-     */
-    public void testTryAcquireN_InterruptedException_fair()
-        throws InterruptedException {
-        final Semaphore s = new Semaphore(1, true);
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                s.tryAcquire(4, MEDIUM_DELAY_MS, MILLISECONDS);
-            }});
-
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     * getQueueLength reports number of waiting threads
-     */
-    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));
-        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() throws Exception {
-        Semaphore l = new Semaphore(3, true);
-
-        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();
-    }
-
-    /**
-     * toString indicates current number of permits
-     */
-    public void testToString() {
-        Semaphore s = new Semaphore(0);
-        String us = s.toString();
-        assertTrue(us.indexOf("Permits = 0") >= 0);
-        s.release();
-        String s1 = s.toString();
-        assertTrue(s1.indexOf("Permits = 1") >= 0);
-        s.release();
-        String s2 = s.toString();
-        assertTrue(s2.indexOf("Permits = 2") >= 0);
-    }
-
-}
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
deleted file mode 100755
index 9393c5c..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/SynchronousQueueTest.java
+++ /dev/null
@@ -1,727 +0,0 @@
-/*
- * 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.io.*;
-
-public class SynchronousQueueTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(SynchronousQueueTest.class);
-    }
-
-    /**
-     * A SynchronousQueue is both empty and full
-     */
-    public void testEmptyFull() {
-        SynchronousQueue q = new SynchronousQueue();
-        assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
-        assertEquals(0, q.remainingCapacity());
-        assertFalse(q.offer(zero));
-    }
-
-    /**
-     * A fair SynchronousQueue is both empty and full
-     */
-    public void testFairEmptyFull() {
-        SynchronousQueue q = new SynchronousQueue(true);
-        assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
-        assertEquals(0, q.remainingCapacity());
-        assertFalse(q.offer(zero));
-    }
-
-    /**
-     * offer(null) throws NPE
-     */
-    public void testOfferNull() {
-        try {
-            SynchronousQueue q = new SynchronousQueue();
-            q.offer(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * add(null) throws NPE
-     */
-    public void testAddNull() {
-        try {
-            SynchronousQueue q = new SynchronousQueue();
-            q.add(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * offer fails if no active taker
-     */
-    public void testOffer() {
-        SynchronousQueue q = new SynchronousQueue();
-        assertFalse(q.offer(one));
-    }
-
-    /**
-     * add throws ISE if no active taker
-     */
-    public void testAdd() {
-        try {
-            SynchronousQueue q = new SynchronousQueue();
-            assertEquals(0, q.remainingCapacity());
-            q.add(one);
-            shouldThrow();
-        } catch (IllegalStateException success) {}
-    }
-
-    /**
-     * addAll(null) throws NPE
-     */
-    public void testAddAll1() {
-        try {
-            SynchronousQueue q = new SynchronousQueue();
-            q.addAll(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * addAll(this) throws IAE
-     */
-    public void testAddAllSelf() {
-        try {
-            SynchronousQueue q = new SynchronousQueue();
-            q.addAll(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * addAll of a collection with null elements throws NPE
-     */
-    public void testAddAll2() {
-        try {
-            SynchronousQueue q = new SynchronousQueue();
-            Integer[] ints = new Integer[1];
-            q.addAll(Arrays.asList(ints));
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-    /**
-     * addAll throws ISE if no active taker
-     */
-    public void testAddAll4() {
-        try {
-            SynchronousQueue q = new SynchronousQueue();
-            Integer[] ints = new Integer[1];
-            for (int i = 0; i < 1; ++i)
-                ints[i] = new Integer(i);
-            q.addAll(Arrays.asList(ints));
-            shouldThrow();
-        } catch (IllegalStateException success) {}
-    }
-
-    /**
-     * put(null) throws NPE
-     */
-    public void testPutNull() throws InterruptedException {
-        try {
-            SynchronousQueue q = new SynchronousQueue();
-            q.put(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-     }
-
-    /**
-     * put blocks interruptibly if no active taker
-     */
-    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();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     * put blocks waiting for take
-     */
-    public void testPutWithTake() throws InterruptedException {
-        final SynchronousQueue q = new SynchronousQueue();
-        Thread t = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                int added = 0;
-                try {
-                    while (true) {
-                        q.put(added);
-                        ++added;
-                    }
-                } catch (InterruptedException success) {
-                    assertTrue(added == 1);
-                }
-            }});
-
-        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() throws InterruptedException {
-        final SynchronousQueue q = new SynchronousQueue();
-        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() throws InterruptedException {
-        final SynchronousQueue q = new SynchronousQueue();
-        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() throws InterruptedException {
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                SynchronousQueue q = new SynchronousQueue(true);
-                q.put(zero);
-            }});
-
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     * put blocks waiting for take
-     */
-    public void testFairPutWithTake() throws InterruptedException {
-        final SynchronousQueue q = new SynchronousQueue(true);
-        Thread t = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                int added = 0;
-                try {
-                    while (true) {
-                        q.put(added);
-                        ++added;
-                    }
-                } catch (InterruptedException success) {
-                    assertTrue(added == 1);
-                }
-            }});
-
-        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() throws InterruptedException {
-        final SynchronousQueue q = new SynchronousQueue(true);
-        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() throws InterruptedException {
-        final SynchronousQueue q = new SynchronousQueue(true);
-        Thread t = new Thread(new CheckedInterruptedRunnable() {
-            public void realRun() throws InterruptedException {
-                q.take();
-            }});
-
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     * poll fails unless active taker
-     */
-    public void testPoll() {
-        SynchronousQueue q = new SynchronousQueue();
-        assertNull(q.poll());
-    }
-
-    /**
-     * timed pool with zero timeout times out if no active taker
-     */
-    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() 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() 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();
-        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 SynchronousQueue q = new SynchronousQueue();
-        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() 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();
-        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() throws InterruptedException {
-        final SynchronousQueue q = new SynchronousQueue(true);
-        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();
-    }
-
-
-    /**
-     * peek returns null
-     */
-    public void testPeek() {
-        SynchronousQueue q = new SynchronousQueue();
-        assertNull(q.peek());
-    }
-
-    /**
-     * element throws NSEE
-     */
-    public void testElement() {
-        SynchronousQueue q = new SynchronousQueue();
-        try {
-            q.element();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove throws NSEE if no active taker
-     */
-    public void testRemove() {
-        SynchronousQueue q = new SynchronousQueue();
-        try {
-            q.remove();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * remove(x) returns false
-     */
-    public void testRemoveElement() {
-        SynchronousQueue q = new SynchronousQueue();
-        assertFalse(q.remove(zero));
-        assertTrue(q.isEmpty());
-    }
-
-    /**
-     * contains returns false
-     */
-    public void testContains() {
-        SynchronousQueue q = new SynchronousQueue();
-        assertFalse(q.contains(zero));
-    }
-
-    /**
-     * clear ensures isEmpty
-     */
-    public void testClear() {
-        SynchronousQueue q = new SynchronousQueue();
-        q.clear();
-        assertTrue(q.isEmpty());
-    }
-
-    /**
-     * containsAll returns false unless empty
-     */
-    public void testContainsAll() {
-        SynchronousQueue q = new SynchronousQueue();
-        Integer[] empty = new Integer[0];
-        assertTrue(q.containsAll(Arrays.asList(empty)));
-        Integer[] ints = new Integer[1]; ints[0] = zero;
-        assertFalse(q.containsAll(Arrays.asList(ints)));
-    }
-
-    /**
-     * retainAll returns false
-     */
-    public void testRetainAll() {
-        SynchronousQueue q = new SynchronousQueue();
-        Integer[] empty = new Integer[0];
-        assertFalse(q.retainAll(Arrays.asList(empty)));
-        Integer[] ints = new Integer[1]; ints[0] = zero;
-        assertFalse(q.retainAll(Arrays.asList(ints)));
-    }
-
-    /**
-     * removeAll returns false
-     */
-    public void testRemoveAll() {
-        SynchronousQueue q = new SynchronousQueue();
-        Integer[] empty = new Integer[0];
-        assertFalse(q.removeAll(Arrays.asList(empty)));
-        Integer[] ints = new Integer[1]; ints[0] = zero;
-        assertFalse(q.containsAll(Arrays.asList(ints)));
-    }
-
-
-    /**
-     * toArray is empty
-     */
-    public void testToArray() {
-        SynchronousQueue q = new SynchronousQueue();
-        Object[] o = q.toArray();
-        assertEquals(o.length, 0);
-    }
-
-    /**
-     * toArray(a) is nulled at position 0
-     */
-    public void testToArray2() {
-        SynchronousQueue q = new SynchronousQueue();
-        Integer[] ints = new Integer[1];
-        assertNull(ints[0]);
-    }
-
-    /**
-     * toArray(null) throws NPE
-     */
-    public void testToArray_BadArg() {
-        SynchronousQueue q = new SynchronousQueue();
-        try {
-            Object o[] = q.toArray(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * iterator does not traverse any elements
-     */
-    public void testIterator() {
-        SynchronousQueue q = new SynchronousQueue();
-        Iterator it = q.iterator();
-        assertFalse(it.hasNext());
-        try {
-            Object x = it.next();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
-    }
-
-    /**
-     * iterator remove throws ISE
-     */
-    public void testIteratorRemove() {
-        SynchronousQueue q = new SynchronousQueue();
-        Iterator it = q.iterator();
-        try {
-            it.remove();
-            shouldThrow();
-        } catch (IllegalStateException success) {
-        } catch (UnsupportedOperationException success) { // android-added
-        }
-    }
-
-    /**
-     * toString returns a non-null string
-     */
-    public void testToString() {
-        SynchronousQueue q = new SynchronousQueue();
-        String s = q.toString();
-        assertNotNull(s);
-    }
-
-
-    /**
-     * offer transfers elements across Executor tasks
-     */
-    public void testOfferInExecutor() {
-        final SynchronousQueue q = new SynchronousQueue();
-        ExecutorService executor = Executors.newFixedThreadPool(2);
-
-        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 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 SynchronousQueue q = new SynchronousQueue();
-        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(SHORT_DELAY_MS);
-                q.put(one);
-            }});
-
-        joinPool(executor);
-    }
-
-    /**
-     * a deserialized serialized queue is usable
-     */
-    public void testSerialization() throws Exception {
-        SynchronousQueue q = new SynchronousQueue();
-        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) {}
-    }
-
-    /**
-     * drainTo(this) throws IAE
-     */
-    public void testDrainToSelf() {
-        SynchronousQueue q = new SynchronousQueue();
-        try {
-            q.drainTo(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * drainTo(c) of empty queue doesn't transfer elements
-     */
-    public void testDrainTo() {
-        SynchronousQueue q = new SynchronousQueue();
-        ArrayList l = new ArrayList();
-        q.drainTo(l);
-        assertEquals(q.size(), 0);
-        assertEquals(l.size(), 0);
-    }
-
-    /**
-     * drainTo empties queue, unblocking a waiting put.
-     */
-    public void testDrainToWithActivePut() throws InterruptedException {
-        final SynchronousQueue q = new SynchronousQueue();
-        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) {}
-    }
-
-    /**
-     * drainTo(this, n) throws IAE
-     */
-    public void testDrainToSelfN() {
-        SynchronousQueue q = new SynchronousQueue();
-        try {
-            q.drainTo(q, 0);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
-    }
-
-    /**
-     * drainTo(c, n) empties up to n elements of queue into c
-     */
-    public void testDrainToN() throws InterruptedException {
-        final SynchronousQueue q = new SynchronousQueue();
-        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
deleted file mode 100644
index e906186..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/SystemTest.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * 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.*;
-
-public class SystemTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(SystemTest.class);
-    }
-
-    /**
-     * Worst case rounding for millisecs; set for 60 cycle millis clock.
-     * This value might need to be changed on JVMs with coarser
-     *  System.currentTimeMillis clocks.
-     */
-    static final long MILLIS_ROUND = 17;
-
-    /**
-     * Nanos between readings of millis is no longer than millis (plus
-     * possible rounding).
-     * This shows only that nano timing not (much) worse than milli.
-     */
-    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);
-    }
-
-    /**
-     * Millis between readings of nanos is less than nanos, adjusting
-     * for rounding.
-     * This shows only that nano timing not (much) worse than milli.
-     */
-    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
deleted file mode 100644
index d54bce0..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadLocalTest.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * 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.concurrent.Semaphore;
-
-public class ThreadLocalTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(ThreadLocalTest.class);
-    }
-
-    static ThreadLocal<Integer> tl = new ThreadLocal<Integer>() {
-            public Integer initialValue() {
-                return one;
-            }
-        };
-
-    static InheritableThreadLocal<Integer> itl =
-        new InheritableThreadLocal<Integer>() {
-            protected Integer initialValue() {
-                return zero;
-            }
-
-            protected Integer childValue(Integer parentValue) {
-                return new Integer(parentValue.intValue() + 1);
-            }
-        };
-
-    /**
-     * remove causes next access to return initial value
-     */
-    public void testRemove() {
-        assertSame(tl.get(), one);
-        tl.set(two);
-        assertSame(tl.get(), two);
-        tl.remove();
-        assertSame(tl.get(), one);
-    }
-
-    /**
-     * remove in InheritableThreadLocal causes next access to return
-     * initial value
-     */
-    public void testRemoveITL() {
-        assertSame(itl.get(), zero);
-        itl.set(two);
-        assertSame(itl.get(), two);
-        itl.remove();
-        assertSame(itl.get(), zero);
-    }
-
-    private class ITLThread extends Thread {
-        final int[] x;
-        ITLThread(int[] array) { x = array; }
-        public void run() {
-            Thread child = null;
-            if (itl.get().intValue() < x.length - 1) {
-                child = new ITLThread(x);
-                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(e);
-                }
-            }
-        }
-    }
-
-    /**
-     * InheritableThreadLocal propagates generic values.
-     */
-    public void testGenericITL() throws InterruptedException {
-        final int threadCount = 10;
-        final int x[] = new int[threadCount];
-        Thread progenitor = new ITLThread(x);
-        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
deleted file mode 100644
index 911a35f..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadPoolExecutorSubclassTest.java
+++ /dev/null
@@ -1,1578 +0,0 @@
-/*
- * 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
deleted file mode 100755
index 9b7fcac..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadPoolExecutorTest.java
+++ /dev/null
@@ -1,1482 +0,0 @@
-/*
- * 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.atomic.*;
-import junit.framework.*;
-import java.util.*;
-
-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, 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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 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, 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, 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, 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 ThreadPoolExecutor(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 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, 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 ThreadPoolExecutor(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 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, 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, 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 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, 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 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; }
-        }
-        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 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; }
-        }
-        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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(-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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(-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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(-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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(-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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(1, 1,
-                                   LONG_DELAY_MS, MILLISECONDS,
-                                   new ArrayBlockingQueue<Runnable>(1));
-        try {
-            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) {}
-            }
-        } finally {
-            joinPool(p);
-        }
-    }
-
-    /**
-     *  executor using CallerRunsPolicy runs task if saturated.
-     */
-    public void testSaturatedExecute2() {
-        RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
-        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) {
-                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 ThreadPoolExecutor.DiscardPolicy();
-        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) {
-                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 ThreadPoolExecutor.DiscardOldestPolicy();
-        ThreadPoolExecutor p = new ThreadPoolExecutor(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 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) {}
-
-        joinPool(tpe);
-    }
-
-    /**
-     *  execute using CallerRunsPolicy drops task on shutdown
-     */
-    public void testCallerRunsOnShutdown() {
-        RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
-        ThreadPoolExecutor p = new ThreadPoolExecutor(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 ThreadPoolExecutor.DiscardPolicy();
-        ThreadPoolExecutor p = new ThreadPoolExecutor(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 ThreadPoolExecutor.DiscardOldestPolicy();
-        ThreadPoolExecutor p = new ThreadPoolExecutor(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 = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
-        try {
-            tpe.execute(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-
-        joinPool(tpe);
-    }
-
-    /**
-     *  setCorePoolSize of negative value throws IllegalArgumentException
-     */
-    public void testCorePoolSizeIllegalArgumentException() {
-        ThreadPoolExecutor tpe =
-            new ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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() {
-        ExtendedTPE tpe = new ExtendedTPE();
-        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 {
-        ExtendedTPE tpe = new ExtendedTPE();
-        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 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);
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * completed submit of runnable returns successfully
-     */
-    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());
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * completed submit of (runnable, result) returns result
-     */
-    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);
-        } finally {
-            joinPool(e);
-        }
-    }
-
-
-    /**
-     * invokeAny(null) throws NPE
-     */
-    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) {
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * invokeAny(empty collection) throws IAE
-     */
-    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) {
-        } 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 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 {
-            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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 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());
-        } finally {
-            joinPool(e);
-        }
-    }
-
-    /**
-     * invokeAll(c) throws NPE if c has null elements
-     */
-    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 {
-            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 ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
-        try {
-            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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 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 {
-            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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 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, 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 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 {
-            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 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 {
-            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 ThreadPoolExecutor(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 ThreadPoolExecutor(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 ThreadPoolExecutor(100, 100, LONG_DELAY_MS, MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory());
-        try {
-            List<Callable<String>> l = new ArrayList<Callable<String>>();
-            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 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() 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,
-                                   new ArrayBlockingQueue(30));
-        try {
-            for (int i = 0; i < nTasks; ++i) {
-                for (;;) {
-                    try {
-                        p.execute(recycledTask);
-                        break;
-                    }
-                    catch (RejectedExecutionException ignore) {
-                    }
-                }
-            }
-            Thread.sleep(5000); // enough time to run all tasks
-            assertEquals(nRun.get(), nTasks);
-        } 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
deleted file mode 100755
index e9f28ac..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/ThreadTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * 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.*;
-
-public class ThreadTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(ThreadTest.class);
-    }
-
-    static class MyHandler implements Thread.UncaughtExceptionHandler {
-        public void uncaughtException(Thread t, Throwable e) {
-            e.printStackTrace();
-        }
-    }
-
-    /**
-     * getUncaughtExceptionHandler returns ThreadGroup unless set,
-     * otherwise returning value of last setUncaughtExceptionHandler.
-     */
-    public void testGetAndSetUncaughtExceptionHandler() {
-        // these must be done all at once to avoid state
-        // dependencies across tests
-        Thread current = Thread.currentThread();
-        ThreadGroup tg = current.getThreadGroup();
-        MyHandler eh = new MyHandler();
-        assertEquals(tg, current.getUncaughtExceptionHandler());
-        current.setUncaughtExceptionHandler(eh);
-        assertEquals(eh, current.getUncaughtExceptionHandler());
-        current.setUncaughtExceptionHandler(null);
-        assertEquals(tg, current.getUncaughtExceptionHandler());
-    }
-
-    /**
-     * getDefaultUncaughtExceptionHandler returns value of last
-     * setDefaultUncaughtExceptionHandler.
-     */
-    public void testGetAndSetDefaultUncaughtExceptionHandler() {
-        assertEquals(null, Thread.getDefaultUncaughtExceptionHandler());
-        // failure due to securityException is OK.
-        // Would be nice to explicitly test both ways, but cannot yet.
-        try {
-            Thread current = Thread.currentThread();
-            ThreadGroup tg = current.getThreadGroup();
-            MyHandler eh = new MyHandler();
-            Thread.setDefaultUncaughtExceptionHandler(eh);
-            assertEquals(eh, Thread.getDefaultUncaughtExceptionHandler());
-            Thread.setDefaultUncaughtExceptionHandler(null);
-        }
-        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
deleted file mode 100755
index 84be0c4..0000000
--- a/concurrent/src/test/java/tests/api/java/util/concurrent/TimeUnitTest.java
+++ /dev/null
@@ -1,427 +0,0 @@
-/*
- * 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.concurrent.*;
-import java.io.*;
-
-public class TimeUnitTest extends JSR166TestCase {
-    public static Test suite() {
-        return new TestSuite(TimeUnitTest.class);
-    }
-
-    // (loops to 88888 check increments at all time divisions.)
-
-    /**
-     * convert correctly converts sample values across the units
-     */
-    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));
-            assertEquals(t,
-                         TimeUnit.SECONDS.convert(1000L*t,
-                                                  TimeUnit.MILLISECONDS));
-            assertEquals(t,
-                         TimeUnit.SECONDS.convert(1000000L*t,
-                                                  TimeUnit.MICROSECONDS));
-            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.SECONDS));
-            assertEquals(t,
-                         TimeUnit.MILLISECONDS.convert(t,
-                                                  TimeUnit.MILLISECONDS));
-            assertEquals(t,
-                         TimeUnit.MILLISECONDS.convert(1000L*t,
-                                                  TimeUnit.MICROSECONDS));
-            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.SECONDS));
-            assertEquals(1000L*t,
-                         TimeUnit.MICROSECONDS.convert(t,
-                                                  TimeUnit.MILLISECONDS));
-            assertEquals(t,
-                         TimeUnit.MICROSECONDS.convert(t,
-                                                  TimeUnit.MICROSECONDS));
-            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.SECONDS));
-            assertEquals(1000000L*t,
-                         TimeUnit.NANOSECONDS.convert(t,
-                                                  TimeUnit.MILLISECONDS));
-            assertEquals(1000L*t,
-                         TimeUnit.NANOSECONDS.convert(t,
-                                                  TimeUnit.MICROSECONDS));
-            assertEquals(t,
-                         TimeUnit.NANOSECONDS.convert(t,
-                                                  TimeUnit.NANOSECONDS));
-        }
-    }
-
-    /**
-     * toNanos correctly converts sample values in different units to
-     * nanoseconds
-     */
-    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,
-                         TimeUnit.MILLISECONDS.toNanos(t));
-            assertEquals(1000L*t,
-                         TimeUnit.MICROSECONDS.toNanos(t));
-            assertEquals(t,
-                         TimeUnit.NANOSECONDS.toNanos(t));
-        }
-    }
-
-    /**
-     * toMicros correctly converts sample values in different units to
-     * microseconds
-     */
-    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,
-                         TimeUnit.MILLISECONDS.toMicros(t));
-            assertEquals(t,
-                         TimeUnit.MICROSECONDS.toMicros(t));
-            assertEquals(t,
-                         TimeUnit.NANOSECONDS.toMicros(t*1000L));
-        }
-    }
-
-    /**
-     * toMillis correctly converts sample values in different units to
-     * milliseconds
-     */
-    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,
-                         TimeUnit.MILLISECONDS.toMillis(t));
-            assertEquals(t,
-                         TimeUnit.MICROSECONDS.toMillis(t*1000L));
-            assertEquals(t,
-                         TimeUnit.NANOSECONDS.toMillis(t*1000000L));
-        }
-    }
-
-    /**
-     * toSeconds correctly converts sample values in different units to
-     * seconds
-     */
-    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,
-                         TimeUnit.MILLISECONDS.toSeconds(t*1000L));
-            assertEquals(t,
-                         TimeUnit.MICROSECONDS.toSeconds(t*1000000L));
-            assertEquals(t,
-                         TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));
-        }
-    }
-
-    /**
-     * 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() {
-        assertEquals(Long.MAX_VALUE,
-                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
-                                                  TimeUnit.SECONDS));
-        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
-     * 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));
-    }
-
-
-    /**
-     * toString returns string containing common name of unit
-     */
-    public void testToString() {
-        String s = TimeUnit.SECONDS.toString();
-        assertTrue(s.indexOf("ECOND") >= 0);
-    }
-
-
-    /**
-     *  Timed wait without holding lock throws
-     *  IllegalMonitorStateException
-     */
-    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();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     * timedWait throws InterruptedException when interrupted
-     */
-    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();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-
-    /**
-     * timedJoin throws InterruptedException when interrupted
-     */
-    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();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-        s.interrupt();
-        s.join();
-    }
-
-    /**
-     *  timedSleep throws InterruptedException when interrupted
-     */
-    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();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     * a deserialized serialized unit is the same instance
-     */
-    public void testSerialization() throws Exception {
-        TimeUnit q = TimeUnit.MILLISECONDS;
-
-        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);
-    }
-
-}
diff --git a/concurrent/src/test/java/tests/concurrent/AllTests.java b/concurrent/src/test/java/tests/concurrent/AllTests.java
deleted file mode 100644
index d599370..0000000
--- a/concurrent/src/test/java/tests/concurrent/AllTests.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package tests.concurrent;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-/**
- * Test suite for the concurrent module
- */
-public class AllTests {
-    /**
-     * Collects all JSR166 unit tests as one suite
-     */ 
-    public static Test suite ( ) {
-        TestSuite suite = new TestSuite("JSR166 Unit Tests");
-
-        suite.addTest(tests.api.java.util.concurrent.JSR166TestCase.suite());
-        
-        return suite;
-    }
-}