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 [16/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/PriorityBlockingQueueTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityBlockingQueueTest.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityBlockingQueueTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityBlockingQueueTest.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,941 @@
+/*
+ * 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 PriorityBlockingQueueTest extends JSR166TestCase {
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+ 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) {
+ int i = ((Integer)x).intValue();
+ int j = ((Integer)y).intValue();
+ if (i < j) return 1;
+ if (i > j) return -1;
+ return 0;
+ }
+ }
+
+ /**
+ * 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() {
+ try {
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE; ++i)
+ ints[i] = new Integer(i);
+ PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints));
+ for (int i = 0; i < SIZE; ++i)
+ assertEquals(ints[i], q.poll());
+ }
+ finally {}
+ }
+
+ /**
+ * The comparator used in constructor is used
+ */
+ public void testConstructor7() {
+ try {
+ MyReverseComparator cmp = new MyReverseComparator();
+ PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE, cmp);
+ assertEquals(cmp, q.comparator());
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE; ++i)
+ ints[i] = new Integer(i);
+ q.addAll(Arrays.asList(ints));
+ for (int i = SIZE-1; i >= 0; --i)
+ assertEquals(ints[i], q.poll());
+ }
+ finally {}
+ }
+
+ /**
+ * 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() {
+ try {
+ Integer[] empty = new Integer[0];
+ Integer[] ints = new Integer[SIZE];
+ for (int i = SIZE-1; i >= 0; --i)
+ ints[i] = new Integer(i);
+ PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
+ assertFalse(q.addAll(Arrays.asList(empty)));
+ assertTrue(q.addAll(Arrays.asList(ints)));
+ for (int i = 0; i < SIZE; ++i)
+ assertEquals(ints[i], q.poll());
+ }
+ finally {}
+ }
+
+ /**
+ * 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() {
+ try {
+ PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ Integer I = new Integer(i);
+ q.put(I);
+ assertTrue(q.contains(I));
+ }
+ assertEquals(SIZE, q.size());
+ }
+ finally {
+ }
+ }
+
+ /**
+ * put doesn't block waiting for take
+ */
+ public void testPutWithTake() {
+ final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ int added = 0;
+ try {
+ q.put(new Integer(0));
+ ++added;
+ q.put(new Integer(0));
+ ++added;
+ q.put(new Integer(0));
+ ++added;
+ q.put(new Integer(0));
+ ++added;
+ threadAssertTrue(added == 4);
+ } finally {
+ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ q.take();
+ t.interrupt();
+ t.join();
+ } catch (Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timed offer does not time out
+ */
+ public void testTimedOffer() {
+ final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ q.put(new Integer(0));
+ q.put(new Integer(0));
+ threadAssertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ threadAssertTrue(q.offer(new Integer(0), LONG_DELAY_MS, TimeUnit.MILLISECONDS));
+ } finally { }
+ }
+ });
+
+ try {
+ t.start();
+ Thread.sleep(SMALL_DELAY_MS);
+ t.interrupt();
+ t.join();
+ } catch (Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * take retrieves elements in priority order
+ */
+ public void testTake() {
+ try {
+ PriorityBlockingQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(i, ((Integer)q.take()).intValue());
+ }
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * take blocks interruptibly when empty
+ */
+ public void testTakeFromEmpty() {
+ final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ q.take();
+ threadShouldThrow();
+ } catch (InterruptedException success){ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ } catch (Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Take removes existing elements until empty, then blocks interruptibly
+ */
+ public void testBlockingTake() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ PriorityBlockingQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ threadAssertEquals(i, ((Integer)q.take()).intValue());
+ }
+ q.take();
+ threadShouldThrow();
+ } catch (InterruptedException success){
+ }
+ }});
+ t.start();
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ }
+ catch (InterruptedException ie) {
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * poll succeeds unless empty
+ */
+ public void testPoll() {
+ PriorityBlockingQueue 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 {
+ PriorityBlockingQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());
+ }
+ assertNull(q.poll(0, TimeUnit.MILLISECONDS));
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timed pool with nonzero timeout succeeds when non-empty, else times out
+ */
+ public void testTimedPoll() {
+ try {
+ PriorityBlockingQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
+ }
+ assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Interrupted timed poll throws InterruptedException instead of
+ * returning timeout status
+ */
+ public void testInterruptedTimedPoll() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ PriorityBlockingQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
+ }
+ threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ } catch (InterruptedException success){
+ }
+ }});
+ 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 PriorityBlockingQueue q = new PriorityBlockingQueue(2);
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
+ q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
+ threadShouldThrow();
+ } catch (InterruptedException success) { }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SMALL_DELAY_MS);
+ assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ t.interrupt();
+ t.join();
+ } catch (Exception e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * peek returns next element, or null if empty
+ */
+ public void testPeek() {
+ PriorityBlockingQueue 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() {
+ PriorityBlockingQueue 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() {
+ PriorityBlockingQueue 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() {
+ 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());
+ assertEquals(NOCAP, q.remainingCapacity());
+ 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() {
+ 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() {
+ PriorityBlockingQueue q = populatedQueue(SIZE);
+ Object[] o = q.toArray();
+ Arrays.sort(o);
+ try {
+ for(int i = 0; i < o.length; i++)
+ assertEquals(o[i], q.take());
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * toArray(a) contains all elements
+ */
+ public void testToArray2() {
+ PriorityBlockingQueue q = populatedQueue(SIZE);
+ Integer[] ints = new Integer[SIZE];
+ ints = (Integer[])q.toArray(ints);
+ Arrays.sort(ints);
+ try {
+ for(int i = 0; i < ints.length; i++)
+ assertEquals(ints[i], q.take());
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * toArray(null) throws NPE
+ */
+ public void testToArray_BadArg() {
+ try {
+ PriorityBlockingQueue q = populatedQueue(SIZE);
+ Object o[] = q.toArray(null);
+ shouldThrow();
+ } catch(NullPointerException success){}
+ }
+
+ /**
+ * toArray with incompatible array type throws CCE
+ */
+ public void testToArray1_BadArg() {
+ try {
+ PriorityBlockingQueue q = populatedQueue(SIZE);
+ 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 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(new Integer(1));
+ }
+ catch (InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ joinPool(executor);
+ }
+
+ /**
+ * A deserialized serialized queue has same elements
+ */
+ public void testSerialization() {
+ PriorityBlockingQueue q = populatedQueue(SIZE);
+ try {
+ ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
+ ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
+ out.writeObject(q);
+ out.close();
+
+ ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
+ ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
+ PriorityBlockingQueue r = (PriorityBlockingQueue)in.readObject();
+ assertEquals(q.size(), r.size());
+ while (!q.isEmpty())
+ assertEquals(q.remove(), r.remove());
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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));
+ }
+
+ /**
+ * drainTo empties queue
+ */
+ public void testDrainToWithActivePut() {
+ final PriorityBlockingQueue q = populatedQueue(SIZE);
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ q.put(new Integer(SIZE+1));
+ }
+ });
+ try {
+ t.start();
+ ArrayList l = new ArrayList();
+ q.drainTo(l);
+ assertTrue(l.size() >= SIZE);
+ for (int i = 0; i < SIZE; ++i)
+ assertEquals(l.get(i), new Integer(i));
+ t.join();
+ assertTrue(q.size() + l.size() >= SIZE);
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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() {
+ for (int i = 0; i < SIZE + 2; ++i) {
+ PriorityBlockingQueue 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)
+ assertTrue(l.contains(new Integer(j)));
+ }
+ }
+
+
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityBlockingQueueTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityQueueTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityQueueTest.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityQueueTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityQueueTest.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,513 @@
+/*
+ * 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 PriorityQueueTest extends JSR166TestCase {
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+ public static Test suite() {
+ return new TestSuite(PriorityQueueTest.class);
+ }
+
+ static class MyReverseComparator implements Comparator {
+ public int compare(Object x, Object y) {
+ int i = ((Integer)x).intValue();
+ int j = ((Integer)y).intValue();
+ if (i < j) return 1;
+ if (i > j) return -1;
+ return 0;
+ }
+ }
+
+ /**
+ * 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() {
+ try {
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE; ++i)
+ ints[i] = new Integer(i);
+ PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
+ for (int i = 0; i < SIZE; ++i)
+ assertEquals(ints[i], q.poll());
+ }
+ finally {}
+ }
+
+ /**
+ * The comparator used in constructor is used
+ */
+ public void testConstructor7() {
+ try {
+ MyReverseComparator cmp = new MyReverseComparator();
+ PriorityQueue q = new PriorityQueue(SIZE, cmp);
+ assertEquals(cmp, q.comparator());
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE; ++i)
+ ints[i] = new Integer(i);
+ q.addAll(Arrays.asList(ints));
+ for (int i = SIZE-1; i >= 0; --i)
+ assertEquals(ints[i], q.poll());
+ }
+ finally {}
+ }
+
+ /**
+ * 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() {
+ try {
+ Integer[] empty = new Integer[0];
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE; ++i)
+ ints[i] = new Integer(SIZE-1-i);
+ PriorityQueue q = new PriorityQueue(SIZE);
+ assertFalse(q.addAll(Arrays.asList(empty)));
+ assertTrue(q.addAll(Arrays.asList(ints)));
+ for (int i = 0; i < SIZE; ++i)
+ assertEquals(new Integer(i), q.poll());
+ }
+ finally {}
+ }
+
+ /**
+ * poll succeeds unless empty
+ */
+ public void testPoll() {
+ PriorityQueue 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() {
+ PriorityQueue 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() {
+ PriorityQueue 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() {
+ PriorityQueue 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() {
+ 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() {
+ PriorityQueue q = populatedQueue(SIZE);
+ try {
+ ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
+ ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
+ out.writeObject(q);
+ out.close();
+
+ ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
+ ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
+ PriorityQueue r = (PriorityQueue)in.readObject();
+ assertEquals(q.size(), r.size());
+ while (!q.isEmpty())
+ assertEquals(q.remove(), r.remove());
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityQueueTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ReentrantLockTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ReentrantLockTest.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ReentrantLockTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ReentrantLockTest.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,1078 @@
+/*
+ * 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.concurrent.locks.*;
+import java.util.concurrent.*;
+import java.util.*;
+import java.io.*;
+
+public class ReentrantLockTest extends JSR166TestCase {
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+ public static Test suite() {
+ return new TestSuite(ReentrantLockTest.class);
+ }
+
+ /**
+ * A runnable calling lockInterruptibly
+ */
+ class InterruptibleLockRunnable implements Runnable {
+ final ReentrantLock lock;
+ InterruptibleLockRunnable(ReentrantLock l) { lock = l; }
+ public void run() {
+ try {
+ lock.lockInterruptibly();
+ } catch(InterruptedException success){}
+ }
+ }
+
+
+ /**
+ * A runnable calling lockInterruptibly that expects to be
+ * interrupted
+ */
+ class InterruptedLockRunnable implements Runnable {
+ final ReentrantLock lock;
+ InterruptedLockRunnable(ReentrantLock l) { lock = l; }
+ public void run() {
+ try {
+ lock.lockInterruptibly();
+ threadShouldThrow();
+ } catch(InterruptedException success){}
+ }
+ }
+
+ /**
+ * 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() {
+ ReentrantLock rl = new ReentrantLock();
+ assertFalse(rl.isFair());
+ ReentrantLock r2 = new ReentrantLock(true);
+ assertTrue(r2.isFair());
+ }
+
+ /**
+ * locking an unlocked lock succeeds
+ */
+ public void testLock() {
+ ReentrantLock rl = new ReentrantLock();
+ rl.lock();
+ assertTrue(rl.isLocked());
+ rl.unlock();
+ }
+
+ /**
+ * 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() {
+ final ReentrantLock lock = new ReentrantLock();
+ Thread t1 = new Thread(new InterruptedLockRunnable(lock));
+ Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
+ try {
+ assertFalse(lock.hasQueuedThreads());
+ lock.lock();
+ t1.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(lock.hasQueuedThreads());
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(lock.hasQueuedThreads());
+ t1.interrupt();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(lock.hasQueuedThreads());
+ lock.unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertFalse(lock.hasQueuedThreads());
+ t1.join();
+ t2.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * getQueueLength reports number of waiting threads
+ */
+ public void testGetQueueLength() {
+ final ReentrantLock lock = new ReentrantLock();
+ Thread t1 = new Thread(new InterruptedLockRunnable(lock));
+ Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
+ try {
+ assertEquals(0, lock.getQueueLength());
+ lock.lock();
+ t1.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(1, lock.getQueueLength());
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(2, lock.getQueueLength());
+ t1.interrupt();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(1, lock.getQueueLength());
+ lock.unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(0, lock.getQueueLength());
+ t1.join();
+ t2.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * getQueueLength reports number of waiting threads
+ */
+ public void testGetQueueLength_fair() {
+ final ReentrantLock lock = new ReentrantLock(true);
+ Thread t1 = new Thread(new InterruptedLockRunnable(lock));
+ Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
+ try {
+ assertEquals(0, lock.getQueueLength());
+ lock.lock();
+ t1.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(1, lock.getQueueLength());
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(2, lock.getQueueLength());
+ t1.interrupt();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(1, lock.getQueueLength());
+ lock.unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertEquals(0, lock.getQueueLength());
+ t1.join();
+ t2.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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() {
+ final ReentrantLock sync = new ReentrantLock();
+ Thread t1 = new Thread(new InterruptedLockRunnable(sync));
+ Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
+ try {
+ assertFalse(sync.hasQueuedThread(t1));
+ assertFalse(sync.hasQueuedThread(t2));
+ sync.lock();
+ t1.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(sync.hasQueuedThread(t1));
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(sync.hasQueuedThread(t1));
+ assertTrue(sync.hasQueuedThread(t2));
+ t1.interrupt();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertFalse(sync.hasQueuedThread(t1));
+ assertTrue(sync.hasQueuedThread(t2));
+ sync.unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertFalse(sync.hasQueuedThread(t1));
+ Thread.sleep(SHORT_DELAY_MS);
+ assertFalse(sync.hasQueuedThread(t2));
+ t1.join();
+ t2.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * getQueuedThreads includes waiting threads
+ */
+ public void testGetQueuedThreads() {
+ final PublicReentrantLock lock = new PublicReentrantLock();
+ Thread t1 = new Thread(new InterruptedLockRunnable(lock));
+ Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
+ try {
+ assertTrue(lock.getQueuedThreads().isEmpty());
+ lock.lock();
+ assertTrue(lock.getQueuedThreads().isEmpty());
+ t1.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(lock.getQueuedThreads().contains(t1));
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(lock.getQueuedThreads().contains(t1));
+ assertTrue(lock.getQueuedThreads().contains(t2));
+ t1.interrupt();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertFalse(lock.getQueuedThreads().contains(t1));
+ assertTrue(lock.getQueuedThreads().contains(t2));
+ lock.unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(lock.getQueuedThreads().isEmpty());
+ t1.join();
+ t2.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * timed tryLock is interruptible.
+ */
+ public void testInterruptedException2() {
+ final ReentrantLock lock = new ReentrantLock();
+ lock.lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
+ threadShouldThrow();
+ } catch(InterruptedException success){}
+ }
+ });
+ try {
+ t.start();
+ t.interrupt();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * TryLock on a locked lock fails
+ */
+ public void testTryLockWhenLocked() {
+ final ReentrantLock lock = new ReentrantLock();
+ lock.lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ threadAssertFalse(lock.tryLock());
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ lock.unlock();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Timed tryLock on a locked lock times out
+ */
+ public void testTryLock_Timeout() {
+ final ReentrantLock lock = new ReentrantLock();
+ lock.lock();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
+ } catch (Exception ex) {
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ lock.unlock();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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() {
+ final ReentrantLock lock = new ReentrantLock();
+ lock.lock();
+ assertTrue(lock.isLocked());
+ lock.unlock();
+ assertFalse(lock.isLocked());
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ lock.lock();
+ try {
+ Thread.sleep(SMALL_DELAY_MS);
+ }
+ catch(Exception e) {
+ threadUnexpectedException();
+ }
+ lock.unlock();
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(lock.isLocked());
+ t.join();
+ assertFalse(lock.isLocked());
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * lockInterruptibly is interruptible.
+ */
+ public void testLockInterruptibly1() {
+ final ReentrantLock lock = new ReentrantLock();
+ lock.lock();
+ Thread t = new Thread(new InterruptedLockRunnable(lock));
+ try {
+ t.start();
+ t.interrupt();
+ lock.unlock();
+ t.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * lockInterruptibly succeeds when unlocked, else is interruptible
+ */
+ public void testLockInterruptibly2() {
+ final ReentrantLock lock = new ReentrantLock();
+ try {
+ lock.lockInterruptibly();
+ } catch(Exception e) {
+ unexpectedException();
+ }
+ Thread t = new Thread(new InterruptedLockRunnable(lock));
+ try {
+ t.start();
+ t.interrupt();
+ assertTrue(lock.isLocked());
+ assertTrue(lock.isHeldByCurrentThread());
+ t.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Calling await without holding lock throws IllegalMonitorStateException
+ */
+ public void testAwait_IllegalMonitor() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ try {
+ c.await();
+ shouldThrow();
+ }
+ catch (IllegalMonitorStateException success) {
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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) {
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * awaitNanos without a signal times out
+ */
+ public void testAwaitNanos_Timeout() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ try {
+ lock.lock();
+ long t = c.awaitNanos(100);
+ assertTrue(t <= 0);
+ lock.unlock();
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timed await without a signal times out
+ */
+ public void testAwait_Timeout() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ try {
+ lock.lock();
+ assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ lock.unlock();
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * awaitUntil without a signal times out
+ */
+ public void testAwaitUntil_Timeout() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ try {
+ lock.lock();
+ java.util.Date d = new java.util.Date();
+ assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
+ lock.unlock();
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * await returns when signalled
+ */
+ public void testAwait() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ c.await();
+ lock.unlock();
+ }
+ catch(InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.lock();
+ c.signal();
+ lock.unlock();
+ t.join(SHORT_DELAY_MS);
+ assertFalse(t.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * hasWaiters throws NPE if null
+ */
+ public void testHasWaitersNPE() {
+ final ReentrantLock lock = new ReentrantLock();
+ try {
+ lock.hasWaiters(null);
+ shouldThrow();
+ } catch (NullPointerException success) {
+ } catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * getWaitQueueLength throws NPE if null
+ */
+ public void testGetWaitQueueLengthNPE() {
+ final ReentrantLock lock = new ReentrantLock();
+ try {
+ lock.getWaitQueueLength(null);
+ shouldThrow();
+ } catch (NullPointerException success) {
+ } catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * getWaitingThreads throws NPE if null
+ */
+ public void testGetWaitingThreadsNPE() {
+ final PublicReentrantLock lock = new PublicReentrantLock();
+ try {
+ lock.getWaitingThreads(null);
+ shouldThrow();
+ } catch (NullPointerException success) {
+ } catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * 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) {
+ } catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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) {
+ } catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * 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) {
+ } catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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) {
+ } catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * 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) {
+ } catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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) {
+ } catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+
+
+ /**
+ * hasWaiters returns true when a thread is waiting, else false
+ */
+ public void testHasWaiters() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ threadAssertFalse(lock.hasWaiters(c));
+ threadAssertEquals(0, lock.getWaitQueueLength(c));
+ c.await();
+ lock.unlock();
+ }
+ catch(InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.lock();
+ assertTrue(lock.hasWaiters(c));
+ assertEquals(1, lock.getWaitQueueLength(c));
+ c.signal();
+ lock.unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.lock();
+ assertFalse(lock.hasWaiters(c));
+ assertEquals(0, lock.getWaitQueueLength(c));
+ lock.unlock();
+ t.join(SHORT_DELAY_MS);
+ assertFalse(t.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * getWaitQueueLength returns number of waiting threads
+ */
+ public void testGetWaitQueueLength() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ Thread t1 = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ threadAssertFalse(lock.hasWaiters(c));
+ threadAssertEquals(0, lock.getWaitQueueLength(c));
+ c.await();
+ lock.unlock();
+ }
+ catch(InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ Thread t2 = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ threadAssertTrue(lock.hasWaiters(c));
+ threadAssertEquals(1, lock.getWaitQueueLength(c));
+ c.await();
+ lock.unlock();
+ }
+ catch(InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ try {
+ t1.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.lock();
+ assertTrue(lock.hasWaiters(c));
+ assertEquals(2, lock.getWaitQueueLength(c));
+ c.signalAll();
+ lock.unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.lock();
+ assertFalse(lock.hasWaiters(c));
+ assertEquals(0, lock.getWaitQueueLength(c));
+ lock.unlock();
+ t1.join(SHORT_DELAY_MS);
+ t2.join(SHORT_DELAY_MS);
+ assertFalse(t1.isAlive());
+ assertFalse(t2.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * getWaitingThreads returns only and all waiting threads
+ */
+ public void testGetWaitingThreads() {
+ final PublicReentrantLock lock = new PublicReentrantLock();
+ final Condition c = lock.newCondition();
+ Thread t1 = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
+ c.await();
+ lock.unlock();
+ }
+ catch(InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ Thread t2 = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
+ c.await();
+ lock.unlock();
+ }
+ catch(InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ try {
+ lock.lock();
+ assertTrue(lock.getWaitingThreads(c).isEmpty());
+ lock.unlock();
+ t1.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.lock();
+ assertTrue(lock.hasWaiters(c));
+ assertTrue(lock.getWaitingThreads(c).contains(t1));
+ assertTrue(lock.getWaitingThreads(c).contains(t2));
+ c.signalAll();
+ lock.unlock();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.lock();
+ assertFalse(lock.hasWaiters(c));
+ assertTrue(lock.getWaitingThreads(c).isEmpty());
+ lock.unlock();
+ t1.join(SHORT_DELAY_MS);
+ t2.join(SHORT_DELAY_MS);
+ assertFalse(t1.isAlive());
+ assertFalse(t2.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+
+
+ /**
+ * awaitUninterruptibly doesn't abort on interrupt
+ */
+ public void testAwaitUninterruptibly() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ lock.lock();
+ c.awaitUninterruptibly();
+ lock.unlock();
+ }
+ });
+
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ lock.lock();
+ c.signal();
+ lock.unlock();
+ assert(t.isInterrupted());
+ t.join(SHORT_DELAY_MS);
+ assertFalse(t.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * await is interruptible
+ */
+ public void testAwait_Interrupt() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ c.await();
+ lock.unlock();
+ threadShouldThrow();
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ });
+
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join(SHORT_DELAY_MS);
+ assertFalse(t.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * awaitNanos is interruptible
+ */
+ public void testAwaitNanos_Interrupt() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ c.awaitNanos(1000 * 1000 * 1000); // 1 sec
+ lock.unlock();
+ threadShouldThrow();
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ });
+
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join(SHORT_DELAY_MS);
+ assertFalse(t.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * awaitUntil is interruptible
+ */
+ public void testAwaitUntil_Interrupt() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ java.util.Date d = new java.util.Date();
+ c.awaitUntil(new java.util.Date(d.getTime() + 10000));
+ lock.unlock();
+ threadShouldThrow();
+ }
+ catch(InterruptedException success) {
+ }
+ }
+ });
+
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join(SHORT_DELAY_MS);
+ assertFalse(t.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * signalAll wakes up all threads
+ */
+ public void testSignalAll() {
+ final ReentrantLock lock = new ReentrantLock();
+ final Condition c = lock.newCondition();
+ Thread t1 = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ c.await();
+ lock.unlock();
+ }
+ catch(InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ Thread t2 = new Thread(new Runnable() {
+ public void run() {
+ try {
+ lock.lock();
+ c.await();
+ lock.unlock();
+ }
+ catch(InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ try {
+ t1.start();
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ lock.lock();
+ c.signalAll();
+ lock.unlock();
+ t1.join(SHORT_DELAY_MS);
+ t2.join(SHORT_DELAY_MS);
+ assertFalse(t1.isAlive());
+ assertFalse(t2.isAlive());
+ }
+ catch (Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * A serialized lock deserializes as unlocked
+ */
+ public void testSerialization() {
+ ReentrantLock l = new ReentrantLock();
+ l.lock();
+ l.unlock();
+
+ try {
+ ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
+ ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
+ out.writeObject(l);
+ out.close();
+
+ ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
+ ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
+ ReentrantLock r = (ReentrantLock) in.readObject();
+ r.lock();
+ r.unlock();
+ } catch(Exception e){
+ e.printStackTrace();
+ unexpectedException();
+ }
+ }
+
+ /**
+ * 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);
+ }
+
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ReentrantLockTest.java
------------------------------------------------------------------------------
svn:eol-style = native