You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by nd...@apache.org on 2006/08/24 05:42:33 UTC
svn commit: r434296 [15/19] - in /incubator/harmony/enhanced/classlib/trunk:
make/ modules/concurrent/ modules/concurrent/.settings/
modules/concurrent/META-INF/ modules/concurrent/make/
modules/concurrent/src/ modules/concurrent/src/main/ modules/conc...
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/JSR166TestCase.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/JSR166TestCase.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/JSR166TestCase.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/JSR166TestCase.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,563 @@
+/*
+ * 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.
+ */
+
+import junit.framework.*;
+import java.util.*;
+import java.util.concurrent.*;
+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 doe 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 {
+ /**
+ * Runs all JSR166 unit tests using junit.textui.TestRunner
+ */
+ public static void main (String[] args) {
+ int iters = 1;
+ if (args.length > 0)
+ iters = Integer.parseInt(args[0]);
+ Test s = suite();
+ for (int i = 0; i < iters; ++i) {
+ junit.textui.TestRunner.run (s);
+ System.gc();
+ System.runFinalization();
+ }
+ System.exit(0);
+ }
+
+ /**
+ * 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(ArrayBlockingQueueTest.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(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(ExchangerTest.class));
+ suite.addTest(new TestSuite(ExecutorsTest.class));
+ suite.addTest(new TestSuite(ExecutorCompletionServiceTest.class));
+ suite.addTest(new TestSuite(FutureTaskTest.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(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(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;
+
+
+ /**
+ * Return the shortest timed delay. This could
+ * be reimplemented to use for example a Property.
+ */
+ protected long getShortDelay() {
+ return 50;
+ }
+
+
+ /**
+ * Set 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;
+
+ /**
+ * Initialize test to indicate that no thread assertions have failed
+ */
+ public void setUp() {
+ setDelays();
+ threadFailed = false;
+ }
+
+ /**
+ * Trigger 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 "Unexpected exception"
+ */
+ public void threadUnexpectedException() {
+ threadFailed = true;
+ fail("Unexpected exception");
+ }
+
+
+ /**
+ * 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, TimeUnit.MILLISECONDS));
+ } catch(SecurityException ok) {
+ // Allowed in case test doesn't have privs
+ } catch(InterruptedException ie) {
+ fail("Unexpected exception");
+ }
+ }
+
+
+ /**
+ * fail with message "should throw exception"
+ */
+ public void shouldThrow() {
+ fail("Should throw exception");
+ }
+
+ /**
+ * fail with message "Unexpected exception"
+ */
+ public void unexpectedException() {
+ fail("Unexpected exception");
+ }
+
+
+ /**
+ * The number of elements to place in collections, arrays, etc.
+ */
+ static final int SIZE = 20;
+
+ // Some convenient Integer constants
+
+ static final Integer zero = new Integer(0);
+ static final Integer one = new Integer(1);
+ static final Integer two = new Integer(2);
+ static final Integer three = new Integer(3);
+ static final Integer four = new Integer(4);
+ static final Integer five = new Integer(5);
+ static final Integer six = new Integer(6);
+ static final Integer seven = new Integer(7);
+ static final Integer eight = new Integer(8);
+ static final Integer nine = new Integer(9);
+ static final Integer m1 = new Integer(-1);
+ static final Integer m2 = new Integer(-2);
+ static final Integer m3 = new Integer(-3);
+ static final Integer m4 = new Integer(-4);
+ static final Integer m5 = new Integer(-5);
+ static final Integer m10 = new Integer(-10);
+
+
+ /**
+ * A security policy where new permissions can be dynamically added
+ * or all cleared.
+ */
+ static class AdjustablePolicy extends java.security.Policy {
+ Permissions perms = new Permissions();
+ AdjustablePolicy() { }
+ 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() {}
+ }
+
+
+ // Some convenient Runnable classes
+
+ static class NoOpRunnable implements Runnable {
+ public void run() {}
+ }
+
+ static class NoOpCallable implements Callable {
+ public Object call() { return Boolean.TRUE; }
+ }
+
+ static final String TEST_STRING = "a test string";
+
+ static class StringTask implements Callable<String> {
+ public String call() { return TEST_STRING; }
+ }
+
+ static class NPETask implements Callable<String> {
+ public String call() { throw new NullPointerException(); }
+ }
+
+ static class CallableOne implements Callable<Integer> {
+ public Integer call() { return one; }
+ }
+
+ class ShortRunnable implements Runnable {
+ public void run() {
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ }
+ catch(Exception e) {
+ threadUnexpectedException();
+ }
+ }
+ }
+
+ class ShortInterruptedRunnable implements Runnable {
+ public void run() {
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ threadShouldThrow();
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ }
+
+ class SmallRunnable implements Runnable {
+ public void run() {
+ try {
+ Thread.sleep(SMALL_DELAY_MS);
+ }
+ catch(Exception e) {
+ threadUnexpectedException();
+ }
+ }
+ }
+
+ class SmallPossiblyInterruptedRunnable implements Runnable {
+ public void run() {
+ try {
+ Thread.sleep(SMALL_DELAY_MS);
+ }
+ catch(Exception e) {
+ }
+ }
+ }
+
+ class SmallCallable implements Callable {
+ public Object call() {
+ try {
+ Thread.sleep(SMALL_DELAY_MS);
+ }
+ catch(Exception e) {
+ threadUnexpectedException();
+ }
+ return Boolean.TRUE;
+ }
+ }
+
+ class SmallInterruptedRunnable implements Runnable {
+ public void run() {
+ try {
+ Thread.sleep(SMALL_DELAY_MS);
+ threadShouldThrow();
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ }
+
+
+ class MediumRunnable implements Runnable {
+ public void run() {
+ try {
+ Thread.sleep(MEDIUM_DELAY_MS);
+ }
+ catch(Exception e) {
+ threadUnexpectedException();
+ }
+ }
+ }
+
+ class MediumInterruptedRunnable implements Runnable {
+ public void run() {
+ try {
+ Thread.sleep(MEDIUM_DELAY_MS);
+ threadShouldThrow();
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ }
+
+ class MediumPossiblyInterruptedRunnable implements Runnable {
+ public void run() {
+ try {
+ Thread.sleep(MEDIUM_DELAY_MS);
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ }
+
+ class LongPossiblyInterruptedRunnable implements Runnable {
+ public void run() {
+ try {
+ Thread.sleep(LONG_DELAY_MS);
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ }
+
+ /**
+ * For use as ThreadFactory in constructors
+ */
+ static class SimpleThreadFactory implements ThreadFactory{
+ public Thread newThread(Runnable r){
+ return new Thread(r);
+ }
+ }
+
+ static class TrackedShortRunnable implements Runnable {
+ volatile boolean done = false;
+ public void run() {
+ try {
+ Thread.sleep(SMALL_DELAY_MS);
+ done = true;
+ } catch(Exception e){
+ }
+ }
+ }
+
+ static class TrackedMediumRunnable implements Runnable {
+ volatile boolean done = false;
+ public void run() {
+ try {
+ Thread.sleep(MEDIUM_DELAY_MS);
+ done = true;
+ } catch(Exception e){
+ }
+ }
+ }
+
+ static class TrackedLongRunnable implements Runnable {
+ volatile boolean done = false;
+ public void run() {
+ try {
+ Thread.sleep(LONG_DELAY_MS);
+ done = true;
+ } catch(Exception e){
+ }
+ }
+ }
+
+ static class TrackedNoOpRunnable implements Runnable {
+ volatile boolean done = false;
+ public void run() {
+ done = true;
+ }
+ }
+
+ static class TrackedCallable implements Callable {
+ volatile boolean done = false;
+ public Object call() {
+ try {
+ Thread.sleep(SMALL_DELAY_MS);
+ done = true;
+ } catch(Exception e){
+ }
+ return Boolean.TRUE;
+ }
+ }
+
+
+ /**
+ * For use as RejectedExecutionHandler in constructors
+ */
+ static class NoOpREHandler implements RejectedExecutionHandler{
+ public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){}
+ }
+
+
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/JSR166TestCase.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedBlockingQueueTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedBlockingQueueTest.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedBlockingQueueTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedBlockingQueueTest.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,1029 @@
+/*
+ * 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.
+ */
+
+import junit.framework.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.io.*;
+
+public class LinkedBlockingQueueTest extends JSR166TestCase {
+
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+
+ 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() {
+ try {
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE; ++i)
+ ints[i] = new Integer(i);
+ LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints));
+ for (int i = 0; i < SIZE; ++i)
+ assertEquals(ints[i], q.poll());
+ }
+ finally {}
+ }
+
+ /**
+ * 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));
+ } 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() {
+ try {
+ Integer[] empty = new Integer[0];
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE; ++i)
+ ints[i] = new Integer(i);
+ LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
+ assertFalse(q.addAll(Arrays.asList(empty)));
+ assertTrue(q.addAll(Arrays.asList(ints)));
+ for (int i = 0; i < SIZE; ++i)
+ assertEquals(ints[i], q.poll());
+ }
+ finally {}
+ }
+
+ /**
+ * put(null) throws NPE
+ */
+ public void testPutNull() {
+ try {
+ LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
+ q.put(null);
+ shouldThrow();
+ }
+ catch (NullPointerException success){
+ }
+ catch (InterruptedException ie) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * all elements successfully put are contained
+ */
+ public void testPut() {
+ try {
+ LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ Integer I = new Integer(i);
+ q.put(I);
+ assertTrue(q.contains(I));
+ }
+ assertEquals(0, q.remainingCapacity());
+ }
+ catch (InterruptedException ie) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * put blocks interruptibly if full
+ */
+ public void testBlockingPut() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ int added = 0;
+ try {
+ LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ q.put(new Integer(i));
+ ++added;
+ }
+ q.put(new Integer(SIZE));
+ threadShouldThrow();
+ } catch (InterruptedException ie){
+ threadAssertEquals(added, SIZE);
+ }
+ }});
+ t.start();
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ }
+ catch (InterruptedException ie) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * put blocks waiting for take when full
+ */
+ public void testPutWithTake() {
+ final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ int added = 0;
+ try {
+ q.put(new Object());
+ ++added;
+ q.put(new Object());
+ ++added;
+ q.put(new Object());
+ ++added;
+ q.put(new Object());
+ ++added;
+ threadShouldThrow();
+ } catch (InterruptedException e){
+ threadAssertTrue(added >= 2);
+ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ q.take();
+ t.interrupt();
+ t.join();
+ } catch (Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timed offer times out if full and elements not taken
+ */
+ public void testTimedOffer() {
+ final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ q.put(new Object());
+ q.put(new Object());
+ threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
+ threadShouldThrow();
+ } catch (InterruptedException success){}
+ }
+ });
+
+ try {
+ t.start();
+ Thread.sleep(SMALL_DELAY_MS);
+ t.interrupt();
+ t.join();
+ } catch (Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * take retrieves elements in FIFO order
+ */
+ public void testTake() {
+ try {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(i, ((Integer)q.take()).intValue());
+ }
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * take blocks interruptibly when empty
+ */
+ public void testTakeFromEmpty() {
+ final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ q.take();
+ threadShouldThrow();
+ } catch (InterruptedException success){ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ } catch (Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Take removes existing elements until empty, then blocks interruptibly
+ */
+ public void testBlockingTake() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(i, ((Integer)q.take()).intValue());
+ }
+ q.take();
+ threadShouldThrow();
+ } catch (InterruptedException success){
+ }
+ }});
+ t.start();
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ }
+ catch (InterruptedException ie) {
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * poll succeeds unless empty
+ */
+ public void testPoll() {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(i, ((Integer)q.poll()).intValue());
+ }
+ assertNull(q.poll());
+ }
+
+ /**
+ * timed pool with zero timeout succeeds when non-empty, else times out
+ */
+ public void testTimedPoll0() {
+ try {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());
+ }
+ assertNull(q.poll(0, TimeUnit.MILLISECONDS));
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timed pool with nonzero timeout succeeds when non-empty, else times out
+ */
+ public void testTimedPoll() {
+ try {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
+ }
+ assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Interrupted timed poll throws InterruptedException instead of
+ * returning timeout status
+ */
+ public void testInterruptedTimedPoll() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
+ }
+ threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ } catch (InterruptedException success){
+ }
+ }});
+ t.start();
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ }
+ catch (InterruptedException ie) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timed poll before a delayed offer fails; after offer succeeds;
+ * on interruption throws
+ */
+ public void testTimedPollWithOffer() {
+ final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
+ q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
+ threadShouldThrow();
+ } catch (InterruptedException success) { }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SMALL_DELAY_MS);
+ assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ t.interrupt();
+ t.join();
+ } catch (Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * peek returns next element, or null if empty
+ */
+ public void testPeek() {
+ LinkedBlockingQueue 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() {
+ LinkedBlockingQueue 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() {
+ LinkedBlockingQueue 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() {
+ 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());
+ }
+
+ /**
+ * 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());
+ 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() {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+ Object[] o = q.toArray();
+ try {
+ for(int i = 0; i < o.length; i++)
+ assertEquals(o[i], q.take());
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * toArray(a) contains all elements
+ */
+ public void testToArray2() {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+ Integer[] ints = new Integer[SIZE];
+ ints = (Integer[])q.toArray(ints);
+ try {
+ for(int i = 0; i < ints.length; i++)
+ assertEquals(ints[i], q.take());
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * toArray(null) throws NPE
+ */
+ public void testToArray_BadArg() {
+ try {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+ Object o[] = q.toArray(null);
+ shouldThrow();
+ } catch(NullPointerException success){}
+ }
+
+ /**
+ * toArray with incompatible array type throws CCE
+ */
+ public void testToArray1_BadArg() {
+ try {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+ Object o[] = q.toArray(new String[10] );
+ shouldThrow();
+ } catch(ArrayStoreException success){}
+ }
+
+
+ /**
+ * iterator iterates through all elements
+ */
+ public void testIterator() {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+ Iterator it = q.iterator();
+ try {
+ while(it.hasNext()){
+ assertEquals(it.next(), q.take());
+ }
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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();
+ assertEquals(it.next(), one);
+ assertEquals(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();) {
+ int i = ((Integer)(it.next())).intValue();
+ assertEquals(++k, i);
+ }
+ 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);
+ try {
+ for (Iterator it = q.iterator(); it.hasNext();) {
+ q.remove();
+ it.next();
+ }
+ }
+ catch (ConcurrentModificationException e) {
+ unexpectedException();
+ }
+ 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 Runnable() {
+ public void run() {
+ threadAssertFalse(q.offer(three));
+ try {
+ threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
+ threadAssertEquals(0, q.remainingCapacity());
+ }
+ catch (InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ executor.execute(new Runnable() {
+ public void run() {
+ try {
+ Thread.sleep(SMALL_DELAY_MS);
+ threadAssertEquals(one, q.take());
+ }
+ catch (InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ 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 Runnable() {
+ public void run() {
+ threadAssertNull(q.poll());
+ try {
+ threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
+ threadAssertTrue(q.isEmpty());
+ }
+ catch (InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ executor.execute(new Runnable() {
+ public void run() {
+ try {
+ Thread.sleep(SMALL_DELAY_MS);
+ q.put(one);
+ }
+ catch (InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ joinPool(executor);
+ }
+
+ /**
+ * A deserialized serialized queue has same elements in same order
+ */
+ public void testSerialization() {
+ LinkedBlockingQueue q = populatedQueue(SIZE);
+
+ try {
+ ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
+ ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
+ out.writeObject(q);
+ out.close();
+
+ ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
+ ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
+ LinkedBlockingQueue r = (LinkedBlockingQueue)in.readObject();
+ assertEquals(q.size(), r.size());
+ while (!q.isEmpty())
+ assertEquals(q.remove(), r.remove());
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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));
+ }
+
+ /**
+ * drainTo empties full queue, unblocking a waiting put.
+ */
+ public void testDrainToWithActivePut() {
+ final LinkedBlockingQueue q = populatedQueue(SIZE);
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ q.put(new Integer(SIZE+1));
+ } catch (InterruptedException ie){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ ArrayList l = new ArrayList();
+ q.drainTo(l);
+ assertTrue(l.size() >= SIZE);
+ for (int i = 0; i < SIZE; ++i)
+ assertEquals(l.get(i), new Integer(i));
+ t.join();
+ assertTrue(q.size() + l.size() >= SIZE);
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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() {
+ for (int i = 0; i < SIZE + 2; ++i) {
+ LinkedBlockingQueue 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);
+ for (int j = 0; j < k; ++j)
+ assertEquals(l.get(j), new Integer(j));
+ }
+ }
+
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedBlockingQueueTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedListTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedListTest.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedListTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedListTest.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,451 @@
+/*
+ * 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.
+ */
+
+import junit.framework.*;
+import java.util.*;
+import java.util.concurrent.*;
+
+public class LinkedListTest extends JSR166TestCase {
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+
+ 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());
+ }
+
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedListTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LockSupportTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LockSupportTest.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LockSupportTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LockSupportTest.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,167 @@
+/*
+ * 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.
+ */
+
+import junit.framework.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.locks.*;
+
+public class LockSupportTest extends JSR166TestCase{
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+ public static Test suite() {
+ return new TestSuite(LockSupportTest.class);
+ }
+
+ /**
+ * park is released by unpark occurring after park
+ */
+ public void testPark() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ LockSupport.park();
+ } catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ LockSupport.unpark(t);
+ t.join();
+ }
+ catch(Exception e) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * park is released by unpark occurring before park
+ */
+ public void testPark2() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ LockSupport.park();
+ } catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ LockSupport.unpark(t);
+ t.join();
+ }
+ catch(Exception e) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * park is released by interrupt
+ */
+ public void testPark3() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ LockSupport.park();
+ threadAssertTrue(Thread.interrupted());
+ } catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ }
+ catch(Exception e) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * park returns if interrupted before park
+ */
+ public void testPark4() {
+ final ReentrantLock lock = new ReentrantLock();
+ lock.lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ LockSupport.park();
+ } catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ t.interrupt();
+ lock.unlock();
+ t.join();
+ }
+ catch(Exception e) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * parkNanos times out if not unparked
+ */
+ public void testParkNanos() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ LockSupport.parkNanos(1000);
+ } catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ }
+ catch(Exception e) {
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * parkUntil times out if not unparked
+ */
+ public void testParkUntil() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ long d = new Date().getTime() + 100;
+ LockSupport.parkUntil(d);
+ } catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ }
+ catch(Exception e) {
+ unexpectedException();
+ }
+ }
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LockSupportTest.java
------------------------------------------------------------------------------
svn:eol-style = native