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 [14/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/DelayQueueTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,981 @@
+/*
+ * 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 DelayQueueTest extends JSR166TestCase {
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+
+ public static Test suite() {
+ return new TestSuite(DelayQueueTest.class);
+ }
+
+ private static final int NOCAP = Integer.MAX_VALUE;
+
+ /**
+ * A delayed implementation for testing.
+ * Most tests use Pseudodelays, where delays are all elapsed
+ * (so, no blocking solely for delays) but are still ordered
+ */
+ static class PDelay implements Delayed {
+ int pseudodelay;
+ PDelay(int i) { pseudodelay = Integer.MIN_VALUE + i; }
+ public int compareTo(Object y) {
+ int i = pseudodelay;
+ int j = ((PDelay)y).pseudodelay;
+ if (i < j) return -1;
+ if (i > j) return 1;
+ return 0;
+ }
+
+ public int compareTo(PDelay y) {
+ int i = pseudodelay;
+ int j = ((PDelay)y).pseudodelay;
+ if (i < j) return -1;
+ if (i > j) return 1;
+ return 0;
+ }
+
+ public boolean equals(Object other) {
+ return ((PDelay)other).pseudodelay == pseudodelay;
+ }
+ public boolean equals(PDelay other) {
+ return ((PDelay)other).pseudodelay == pseudodelay;
+ }
+
+
+ public long getDelay(TimeUnit ignore) {
+ return pseudodelay;
+ }
+ public int intValue() {
+ return pseudodelay;
+ }
+
+ public String toString() {
+ return String.valueOf(pseudodelay);
+ }
+ }
+
+
+ /**
+ * Delayed implementation that actually delays
+ */
+ static class NanoDelay implements Delayed {
+ long trigger;
+ NanoDelay(long i) {
+ trigger = System.nanoTime() + i;
+ }
+ public int compareTo(Object y) {
+ long i = trigger;
+ long j = ((NanoDelay)y).trigger;
+ if (i < j) return -1;
+ if (i > j) return 1;
+ return 0;
+ }
+
+ public int compareTo(NanoDelay y) {
+ long i = trigger;
+ long j = ((NanoDelay)y).trigger;
+ if (i < j) return -1;
+ if (i > j) return 1;
+ return 0;
+ }
+
+ public boolean equals(Object other) {
+ return ((NanoDelay)other).trigger == trigger;
+ }
+ public boolean equals(NanoDelay other) {
+ return ((NanoDelay)other).trigger == trigger;
+ }
+
+ public long getDelay(TimeUnit unit) {
+ long n = trigger - System.nanoTime();
+ return unit.convert(n, TimeUnit.NANOSECONDS);
+ }
+
+ public long getTriggerTime() {
+ return trigger;
+ }
+
+ public String toString() {
+ return String.valueOf(trigger);
+ }
+ }
+
+
+ /**
+ * Create a queue of given size containing consecutive
+ * PDelays 0 ... n.
+ */
+ private DelayQueue populatedQueue(int n) {
+ DelayQueue q = new DelayQueue();
+ assertTrue(q.isEmpty());
+ for(int i = n-1; i >= 0; i-=2)
+ assertTrue(q.offer(new PDelay(i)));
+ for(int i = (n & 1); i < n; i+=2)
+ assertTrue(q.offer(new PDelay(i)));
+ assertFalse(q.isEmpty());
+ assertEquals(NOCAP, q.remainingCapacity());
+ assertEquals(n, q.size());
+ return q;
+ }
+
+ /**
+ * A new queue has unbounded capacity
+ */
+ public void testConstructor1() {
+ assertEquals(NOCAP, new DelayQueue().remainingCapacity());
+ }
+
+ /**
+ * Initializing from null Collection throws NPE
+ */
+ public void testConstructor3() {
+ try {
+ DelayQueue q = new DelayQueue(null);
+ shouldThrow();
+ }
+ catch (NullPointerException success) {}
+ }
+
+ /**
+ * Initializing from Collection of null elements throws NPE
+ */
+ public void testConstructor4() {
+ try {
+ PDelay[] ints = new PDelay[SIZE];
+ DelayQueue q = new DelayQueue(Arrays.asList(ints));
+ shouldThrow();
+ }
+ catch (NullPointerException success) {}
+ }
+
+ /**
+ * Initializing from Collection with some null elements throws NPE
+ */
+ public void testConstructor5() {
+ try {
+ PDelay[] ints = new PDelay[SIZE];
+ for (int i = 0; i < SIZE-1; ++i)
+ ints[i] = new PDelay(i);
+ DelayQueue q = new DelayQueue(Arrays.asList(ints));
+ shouldThrow();
+ }
+ catch (NullPointerException success) {}
+ }
+
+ /**
+ * Queue contains all elements of collection used to initialize
+ */
+ public void testConstructor6() {
+ try {
+ PDelay[] ints = new PDelay[SIZE];
+ for (int i = 0; i < SIZE; ++i)
+ ints[i] = new PDelay(i);
+ DelayQueue q = new DelayQueue(Arrays.asList(ints));
+ for (int i = 0; i < SIZE; ++i)
+ assertEquals(ints[i], q.poll());
+ }
+ finally {}
+ }
+
+ /**
+ * isEmpty is true before add, false after
+ */
+ public void testEmpty() {
+ DelayQueue q = new DelayQueue();
+ assertTrue(q.isEmpty());
+ assertEquals(NOCAP, q.remainingCapacity());
+ q.add(new PDelay(1));
+ assertFalse(q.isEmpty());
+ q.add(new PDelay(2));
+ q.remove();
+ q.remove();
+ assertTrue(q.isEmpty());
+ }
+
+ /**
+ * remainingCapacity does not change when elementa added or removed,
+ * but size does
+ */
+ public void testRemainingCapacity() {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(NOCAP, q.remainingCapacity());
+ assertEquals(SIZE-i, q.size());
+ q.remove();
+ }
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(NOCAP, q.remainingCapacity());
+ assertEquals(i, q.size());
+ q.add(new PDelay(i));
+ }
+ }
+
+ /**
+ * offer(null) throws NPE
+ */
+ public void testOfferNull() {
+ try {
+ DelayQueue q = new DelayQueue();
+ q.offer(null);
+ shouldThrow();
+ } catch (NullPointerException success) { }
+ }
+
+ /**
+ * add(null) throws NPE
+ */
+ public void testAddNull() {
+ try {
+ DelayQueue q = new DelayQueue();
+ q.add(null);
+ shouldThrow();
+ } catch (NullPointerException success) { }
+ }
+
+ /**
+ * offer non-null succeeds
+ */
+ public void testOffer() {
+ DelayQueue q = new DelayQueue();
+ assertTrue(q.offer(new PDelay(0)));
+ assertTrue(q.offer(new PDelay(1)));
+ }
+
+ /**
+ * add succeeds
+ */
+ public void testAdd() {
+ DelayQueue q = new DelayQueue();
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(i, q.size());
+ assertTrue(q.add(new PDelay(i)));
+ }
+ }
+
+ /**
+ * addAll(null) throws NPE
+ */
+ public void testAddAll1() {
+ try {
+ DelayQueue q = new DelayQueue();
+ q.addAll(null);
+ shouldThrow();
+ }
+ catch (NullPointerException success) {}
+ }
+
+
+ /**
+ * addAll(this) throws IAE
+ */
+ public void testAddAllSelf() {
+ try {
+ DelayQueue q = populatedQueue(SIZE);
+ q.addAll(q);
+ shouldThrow();
+ }
+ catch (IllegalArgumentException success) {}
+ }
+
+ /**
+ * addAll of a collection with null elements throws NPE
+ */
+ public void testAddAll2() {
+ try {
+ DelayQueue q = new DelayQueue();
+ PDelay[] ints = new PDelay[SIZE];
+ q.addAll(Arrays.asList(ints));
+ shouldThrow();
+ }
+ catch (NullPointerException success) {}
+ }
+ /**
+ * addAll of a collection with any null elements throws NPE after
+ * possibly adding some elements
+ */
+ public void testAddAll3() {
+ try {
+ DelayQueue q = new DelayQueue();
+ PDelay[] ints = new PDelay[SIZE];
+ for (int i = 0; i < SIZE-1; ++i)
+ ints[i] = new PDelay(i);
+ q.addAll(Arrays.asList(ints));
+ shouldThrow();
+ }
+ catch (NullPointerException success) {}
+ }
+
+ /**
+ * Queue contains all elements of successful addAll
+ */
+ public void testAddAll5() {
+ try {
+ PDelay[] empty = new PDelay[0];
+ PDelay[] ints = new PDelay[SIZE];
+ for (int i = SIZE-1; i >= 0; --i)
+ ints[i] = new PDelay(i);
+ DelayQueue q = new DelayQueue();
+ assertFalse(q.addAll(Arrays.asList(empty)));
+ assertTrue(q.addAll(Arrays.asList(ints)));
+ for (int i = 0; i < SIZE; ++i)
+ assertEquals(ints[i], q.poll());
+ }
+ finally {}
+ }
+
+ /**
+ * put(null) throws NPE
+ */
+ public void testPutNull() {
+ try {
+ DelayQueue q = new DelayQueue();
+ q.put(null);
+ shouldThrow();
+ }
+ catch (NullPointerException success){
+ }
+ }
+
+ /**
+ * all elements successfully put are contained
+ */
+ public void testPut() {
+ try {
+ DelayQueue q = new DelayQueue();
+ for (int i = 0; i < SIZE; ++i) {
+ PDelay I = new PDelay(i);
+ q.put(I);
+ assertTrue(q.contains(I));
+ }
+ assertEquals(SIZE, q.size());
+ }
+ finally {
+ }
+ }
+
+ /**
+ * put doesn't block waiting for take
+ */
+ public void testPutWithTake() {
+ final DelayQueue q = new DelayQueue();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ int added = 0;
+ try {
+ q.put(new PDelay(0));
+ ++added;
+ q.put(new PDelay(0));
+ ++added;
+ q.put(new PDelay(0));
+ ++added;
+ q.put(new PDelay(0));
+ ++added;
+ threadAssertTrue(added == 4);
+ } finally {
+ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ q.take();
+ t.interrupt();
+ t.join();
+ } catch (Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timed offer does not time out
+ */
+ public void testTimedOffer() {
+ final DelayQueue q = new DelayQueue();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ q.put(new PDelay(0));
+ q.put(new PDelay(0));
+ threadAssertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ threadAssertTrue(q.offer(new PDelay(0), LONG_DELAY_MS, TimeUnit.MILLISECONDS));
+ } finally { }
+ }
+ });
+
+ 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 {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(new PDelay(i), ((PDelay)q.take()));
+ }
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * take blocks interruptibly when empty
+ */
+ public void testTakeFromEmpty() {
+ final DelayQueue q = new DelayQueue();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ q.take();
+ threadShouldThrow();
+ } catch (InterruptedException success){ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ } catch (Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Take removes existing elements until empty, then blocks interruptibly
+ */
+ public void testBlockingTake() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ threadAssertEquals(new PDelay(i), ((PDelay)q.take()));
+ }
+ q.take();
+ threadShouldThrow();
+ } catch (InterruptedException success){
+ }
+ }});
+ t.start();
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ }
+ catch (InterruptedException ie) {
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * poll succeeds unless empty
+ */
+ public void testPoll() {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(new PDelay(i), ((PDelay)q.poll()));
+ }
+ assertNull(q.poll());
+ }
+
+ /**
+ * timed pool with zero timeout succeeds when non-empty, else times out
+ */
+ public void testTimedPoll0() {
+ try {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(new PDelay(i), ((PDelay)q.poll(0, TimeUnit.MILLISECONDS)));
+ }
+ assertNull(q.poll(0, TimeUnit.MILLISECONDS));
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timed pool with nonzero timeout succeeds when non-empty, else times out
+ */
+ public void testTimedPoll() {
+ try {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)));
+ }
+ assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Interrupted timed poll throws InterruptedException instead of
+ * returning timeout status
+ */
+ public void testInterruptedTimedPoll() {
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ threadAssertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)));
+ }
+ threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ } catch (InterruptedException success){
+ }
+ }});
+ 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 DelayQueue q = new DelayQueue();
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
+ q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
+ threadFail("Should block");
+ } catch (InterruptedException success) { }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SMALL_DELAY_MS);
+ assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+ t.interrupt();
+ t.join();
+ } catch (Exception e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * peek returns next element, or null if empty
+ */
+ public void testPeek() {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(new PDelay(i), ((PDelay)q.peek()));
+ q.poll();
+ assertTrue(q.peek() == null ||
+ i != ((PDelay)q.peek()).intValue());
+ }
+ assertNull(q.peek());
+ }
+
+ /**
+ * element returns next element, or throws NSEE if empty
+ */
+ public void testElement() {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(new PDelay(i), ((PDelay)q.element()));
+ q.poll();
+ }
+ try {
+ q.element();
+ shouldThrow();
+ }
+ catch (NoSuchElementException success) {}
+ }
+
+ /**
+ * remove removes next element, or throws NSEE if empty
+ */
+ public void testRemove() {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertEquals(new PDelay(i), ((PDelay)q.remove()));
+ }
+ try {
+ q.remove();
+ shouldThrow();
+ } catch (NoSuchElementException success){
+ }
+ }
+
+ /**
+ * remove(x) removes x and returns true if present
+ */
+ public void testRemoveElement() {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 1; i < SIZE; i+=2) {
+ assertTrue(q.remove(new PDelay(i)));
+ }
+ for (int i = 0; i < SIZE; i+=2) {
+ assertTrue(q.remove(new PDelay(i)));
+ assertFalse(q.remove(new PDelay(i+1)));
+ }
+ assertTrue(q.isEmpty());
+ }
+
+ /**
+ * contains(x) reports true when elements added but not yet removed
+ */
+ public void testContains() {
+ DelayQueue q = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertTrue(q.contains(new PDelay(i)));
+ q.poll();
+ assertFalse(q.contains(new PDelay(i)));
+ }
+ }
+
+ /**
+ * clear removes all elements
+ */
+ public void testClear() {
+ DelayQueue q = populatedQueue(SIZE);
+ q.clear();
+ assertTrue(q.isEmpty());
+ assertEquals(0, q.size());
+ assertEquals(NOCAP, q.remainingCapacity());
+ q.add(new PDelay(1));
+ assertFalse(q.isEmpty());
+ q.clear();
+ assertTrue(q.isEmpty());
+ }
+
+ /**
+ * containsAll(c) is true when c contains a subset of elements
+ */
+ public void testContainsAll() {
+ DelayQueue q = populatedQueue(SIZE);
+ DelayQueue p = new DelayQueue();
+ for (int i = 0; i < SIZE; ++i) {
+ assertTrue(q.containsAll(p));
+ assertFalse(p.containsAll(q));
+ p.add(new PDelay(i));
+ }
+ assertTrue(p.containsAll(q));
+ }
+
+ /**
+ * retainAll(c) retains only those elements of c and reports true if changed
+ */
+ public void testRetainAll() {
+ DelayQueue q = populatedQueue(SIZE);
+ DelayQueue p = populatedQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ boolean changed = q.retainAll(p);
+ if (i == 0)
+ assertFalse(changed);
+ else
+ assertTrue(changed);
+
+ assertTrue(q.containsAll(p));
+ assertEquals(SIZE-i, q.size());
+ p.remove();
+ }
+ }
+
+ /**
+ * removeAll(c) removes only those elements of c and reports true if changed
+ */
+ public void testRemoveAll() {
+ for (int i = 1; i < SIZE; ++i) {
+ DelayQueue q = populatedQueue(SIZE);
+ DelayQueue p = populatedQueue(i);
+ assertTrue(q.removeAll(p));
+ assertEquals(SIZE-i, q.size());
+ for (int j = 0; j < i; ++j) {
+ PDelay I = (PDelay)(p.remove());
+ assertFalse(q.contains(I));
+ }
+ }
+ }
+
+ /**
+ * toArray contains all elements
+ */
+ public void testToArray() {
+ DelayQueue 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() {
+ DelayQueue q = populatedQueue(SIZE);
+ PDelay[] ints = new PDelay[SIZE];
+ ints = (PDelay[])q.toArray(ints);
+ Arrays.sort(ints);
+ try {
+ for(int i = 0; i < ints.length; i++)
+ assertEquals(ints[i], q.take());
+ } catch (InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * toArray(null) throws NPE
+ */
+ public void testToArray_BadArg() {
+ try {
+ DelayQueue q = populatedQueue(SIZE);
+ Object o[] = q.toArray(null);
+ shouldThrow();
+ } catch(NullPointerException success){}
+ }
+
+ /**
+ * toArray with incompatible array type throws CCE
+ */
+ public void testToArray1_BadArg() {
+ try {
+ DelayQueue q = populatedQueue(SIZE);
+ Object o[] = q.toArray(new String[10] );
+ shouldThrow();
+ } catch(ArrayStoreException success){}
+ }
+
+ /**
+ * iterator iterates through all elements
+ */
+ public void testIterator() {
+ DelayQueue q = populatedQueue(SIZE);
+ int i = 0;
+ Iterator it = q.iterator();
+ while(it.hasNext()) {
+ assertTrue(q.contains(it.next()));
+ ++i;
+ }
+ assertEquals(i, SIZE);
+ }
+
+ /**
+ * iterator.remove removes current element
+ */
+ public void testIteratorRemove () {
+ final DelayQueue q = new DelayQueue();
+ q.add(new PDelay(2));
+ q.add(new PDelay(1));
+ q.add(new PDelay(3));
+ Iterator it = q.iterator();
+ it.next();
+ it.remove();
+ it = q.iterator();
+ assertEquals(it.next(), new PDelay(2));
+ assertEquals(it.next(), new PDelay(3));
+ assertFalse(it.hasNext());
+ }
+
+
+ /**
+ * toString contains toStrings of elements
+ */
+ public void testToString() {
+ DelayQueue q = populatedQueue(SIZE);
+ String s = q.toString();
+ for (int i = 0; i < SIZE; ++i) {
+ assertTrue(s.indexOf(String.valueOf(Integer.MIN_VALUE+i)) >= 0);
+ }
+ }
+
+ /**
+ * offer transfers elements across Executor tasks
+ */
+ public void testPollInExecutor() {
+ final DelayQueue q = new DelayQueue();
+ ExecutorService executor = Executors.newFixedThreadPool(2);
+ executor.execute(new 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(SHORT_DELAY_MS);
+ q.put(new PDelay(1));
+ }
+ catch (InterruptedException e) {
+ threadUnexpectedException();
+ }
+ }
+ });
+ joinPool(executor);
+
+ }
+
+
+ /**
+ * Delayed actions do not occur until their delay elapses
+ */
+ public void testDelay() {
+ DelayQueue q = new DelayQueue();
+ NanoDelay[] elements = new NanoDelay[SIZE];
+ for (int i = 0; i < SIZE; ++i) {
+ elements[i] = new NanoDelay(1000000000L + 1000000L * (SIZE - i));
+ }
+ for (int i = 0; i < SIZE; ++i) {
+ q.add(elements[i]);
+ }
+
+ try {
+ long last = 0;
+ for (int i = 0; i < SIZE; ++i) {
+ NanoDelay e = (NanoDelay)(q.take());
+ long tt = e.getTriggerTime();
+ assertTrue(tt <= System.nanoTime());
+ if (i != 0)
+ assertTrue(tt >= last);
+ last = tt;
+ }
+ }
+ catch(InterruptedException ie) {
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * drainTo(null) throws NPE
+ */
+ public void testDrainToNull() {
+ DelayQueue q = populatedQueue(SIZE);
+ try {
+ q.drainTo(null);
+ shouldThrow();
+ } catch(NullPointerException success) {
+ }
+ }
+
+ /**
+ * drainTo(this) throws IAE
+ */
+ public void testDrainToSelf() {
+ DelayQueue q = populatedQueue(SIZE);
+ try {
+ q.drainTo(q);
+ shouldThrow();
+ } catch(IllegalArgumentException success) {
+ }
+ }
+
+ /**
+ * drainTo(c) empties queue into another collection c
+ */
+ public void testDrainTo() {
+ DelayQueue q = populatedQueue(SIZE);
+ ArrayList l = new ArrayList();
+ q.drainTo(l);
+ assertEquals(q.size(), 0);
+ assertEquals(l.size(), SIZE);
+ }
+
+ /**
+ * drainTo empties queue
+ */
+ public void testDrainToWithActivePut() {
+ final DelayQueue q = populatedQueue(SIZE);
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ q.put(new PDelay(SIZE+1));
+ }
+ });
+ try {
+ t.start();
+ ArrayList l = new ArrayList();
+ q.drainTo(l);
+ assertTrue(l.size() >= SIZE);
+ t.join();
+ assertTrue(q.size() + l.size() >= SIZE);
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * drainTo(null, n) throws NPE
+ */
+ public void testDrainToNullN() {
+ DelayQueue q = populatedQueue(SIZE);
+ try {
+ q.drainTo(null, 0);
+ shouldThrow();
+ } catch(NullPointerException success) {
+ }
+ }
+
+ /**
+ * drainTo(this, n) throws IAE
+ */
+ public void testDrainToSelfN() {
+ DelayQueue q = populatedQueue(SIZE);
+ try {
+ q.drainTo(q, 0);
+ shouldThrow();
+ } catch(IllegalArgumentException success) {
+ }
+ }
+
+ /**
+ * drainTo(c, n) empties first max {n, size} elements of queue into c
+ */
+ public void testDrainToN() {
+ for (int i = 0; i < SIZE + 2; ++i) {
+ DelayQueue q = populatedQueue(SIZE);
+ ArrayList l = new ArrayList();
+ q.drainTo(l, i);
+ int k = (i < SIZE)? i : SIZE;
+ assertEquals(q.size(), SIZE-k);
+ assertEquals(l.size(), k);
+ }
+ }
+
+
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,232 @@
+/*
+ * 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 ExchangerTest extends JSR166TestCase {
+
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+ public static Test suite() {
+ return new TestSuite(ExchangerTest.class);
+ }
+
+ /**
+ * exchange exchanges objects across two threads
+ */
+ public void testExchange() {
+ final Exchanger e = new Exchanger();
+ Thread t1 = new Thread(new Runnable(){
+ public void run(){
+ try {
+ Object v = e.exchange(one);
+ threadAssertEquals(v, two);
+ Object w = e.exchange(v);
+ threadAssertEquals(w, one);
+ } catch(InterruptedException e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ Thread t2 = new Thread(new Runnable(){
+ public void run(){
+ try {
+ Object v = e.exchange(two);
+ threadAssertEquals(v, one);
+ Object w = e.exchange(v);
+ threadAssertEquals(w, two);
+ } catch(InterruptedException e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t1.start();
+ t2.start();
+ t1.join();
+ t2.join();
+ } catch(InterruptedException ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timed exchange exchanges objects across two threads
+ */
+ public void testTimedExchange() {
+ final Exchanger e = new Exchanger();
+ Thread t1 = new Thread(new Runnable(){
+ public void run(){
+ try {
+ Object v = e.exchange(one, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
+ threadAssertEquals(v, two);
+ Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
+ threadAssertEquals(w, one);
+ } catch(InterruptedException e){
+ threadUnexpectedException();
+ } catch(TimeoutException toe) {
+ threadUnexpectedException();
+ }
+ }
+ });
+ Thread t2 = new Thread(new Runnable(){
+ public void run(){
+ try {
+ Object v = e.exchange(two, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
+ threadAssertEquals(v, one);
+ Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
+ threadAssertEquals(w, two);
+ } catch(InterruptedException e){
+ threadUnexpectedException();
+ } catch(TimeoutException toe) {
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t1.start();
+ t2.start();
+ t1.join();
+ t2.join();
+ } catch(InterruptedException ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * interrupt during wait for exchange throws IE
+ */
+ public void testExchange_InterruptedException(){
+ final Exchanger e = new Exchanger();
+ Thread t = new Thread(new Runnable() {
+ public void run(){
+ try {
+ e.exchange(one);
+ threadShouldThrow();
+ } catch(InterruptedException success){
+ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ } catch(InterruptedException ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * interrupt during wait for timed exchange throws IE
+ */
+ public void testTimedExchange_InterruptedException(){
+ final Exchanger e = new Exchanger();
+ Thread t = new Thread(new Runnable() {
+ public void run(){
+ try {
+ e.exchange(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
+ threadShouldThrow();
+ } catch(InterruptedException success){
+ } catch(Exception e2){
+ threadFail("should throw IE");
+ }
+ }
+ });
+ try {
+ t.start();
+ t.interrupt();
+ t.join();
+ } catch(InterruptedException ex){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timeout during wait for timed exchange throws TOE
+ */
+ public void testExchange_TimeOutException(){
+ final Exchanger e = new Exchanger();
+ Thread t = new Thread(new Runnable() {
+ public void run(){
+ try {
+ e.exchange(null, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
+ threadShouldThrow();
+ } catch(TimeoutException success){
+ } catch(InterruptedException e2){
+ threadFail("should throw TOE");
+ }
+ }
+ });
+ try {
+ t.start();
+ t.join();
+ } catch(InterruptedException ex){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * If one exchanging thread is interrupted, another succeeds.
+ */
+ public void testReplacementAfterExchange() {
+ final Exchanger e = new Exchanger();
+ Thread t1 = new Thread(new Runnable(){
+ public void run(){
+ try {
+ Object v = e.exchange(one);
+ threadAssertEquals(v, two);
+ Object w = e.exchange(v);
+ threadShouldThrow();
+ } catch(InterruptedException success){
+ }
+ }
+ });
+ Thread t2 = new Thread(new Runnable(){
+ public void run(){
+ try {
+ Object v = e.exchange(two);
+ threadAssertEquals(v, one);
+ Thread.sleep(SMALL_DELAY_MS);
+ Object w = e.exchange(v);
+ threadAssertEquals(w, three);
+ } catch(InterruptedException e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ Thread t3 = new Thread(new Runnable(){
+ public void run(){
+ try {
+ Thread.sleep(SMALL_DELAY_MS);
+ Object w = e.exchange(three);
+ threadAssertEquals(w, one);
+ } catch(InterruptedException e){
+ threadUnexpectedException();
+ }
+ }
+ });
+
+ try {
+ t1.start();
+ t2.start();
+ t3.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t1.interrupt();
+ t1.join();
+ t2.join();
+ t3.join();
+ } catch(InterruptedException ex) {
+ unexpectedException();
+ }
+ }
+
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,161 @@
+/*
+ * 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.math.BigInteger;
+import java.security.*;
+
+public class ExecutorCompletionServiceTest extends JSR166TestCase{
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+ public static Test suite() {
+ return new TestSuite(ExecutorCompletionServiceTest.class);
+ }
+
+
+ /**
+ * Creating a new ECS with null Executor throw NPE
+ */
+ public void testConstructorNPE() {
+ try {
+ ExecutorCompletionService ecs = new ExecutorCompletionService(null);
+ shouldThrow();
+ } catch (NullPointerException success) {
+ }
+ }
+
+ /**
+ * Creating a new ECS with null queue throw NPE
+ */
+ public void testConstructorNPE2() {
+ try {
+ ExecutorService e = Executors.newCachedThreadPool();
+ ExecutorCompletionService ecs = new ExecutorCompletionService(e, null);
+ shouldThrow();
+ } catch (NullPointerException success) {
+ }
+ }
+
+ /**
+ * Submitting a null callable throws NPE
+ */
+ public void testSubmitNPE() {
+ ExecutorService e = Executors.newCachedThreadPool();
+ ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+ try {
+ Callable c = null;
+ ecs.submit(c);
+ shouldThrow();
+ } catch (NullPointerException success) {
+ } finally {
+ joinPool(e);
+ }
+ }
+
+ /**
+ * Submitting a null runnable throws NPE
+ */
+ public void testSubmitNPE2() {
+ ExecutorService e = Executors.newCachedThreadPool();
+ ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+ try {
+ Runnable r = null;
+ ecs.submit(r, Boolean.TRUE);
+ shouldThrow();
+ } catch (NullPointerException success) {
+ } finally {
+ joinPool(e);
+ }
+ }
+
+ /**
+ * A taken submitted task is completed
+ */
+ public void testTake() {
+ ExecutorService e = Executors.newCachedThreadPool();
+ ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+ try {
+ Callable c = new StringTask();
+ ecs.submit(c);
+ Future f = ecs.take();
+ assert(f.isDone());
+ } catch (Exception ex) {
+ unexpectedException();
+ } finally {
+ joinPool(e);
+ }
+ }
+
+ /**
+ * Take returns the same future object returned by submit
+ */
+ public void testTake2() {
+ ExecutorService e = Executors.newCachedThreadPool();
+ ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+ try {
+ Callable c = new StringTask();
+ Future f1 = ecs.submit(c);
+ Future f2 = ecs.take();
+ assertSame(f1, f2);
+ } catch (Exception ex) {
+ unexpectedException();
+ } finally {
+ joinPool(e);
+ }
+ }
+
+ /**
+ * If poll returns non-null, the returned task is completed
+ */
+ public void testPoll1() {
+ ExecutorService e = Executors.newCachedThreadPool();
+ ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+ try {
+ assertNull(ecs.poll());
+ Callable c = new StringTask();
+ ecs.submit(c);
+ Thread.sleep(SHORT_DELAY_MS);
+ for (;;) {
+ Future f = ecs.poll();
+ if (f != null) {
+ assert(f.isDone());
+ break;
+ }
+ }
+ } catch (Exception ex) {
+ unexpectedException();
+ } finally {
+ joinPool(e);
+ }
+ }
+
+ /**
+ * If timed poll returns non-null, the returned task is completed
+ */
+ public void testPoll2() {
+ ExecutorService e = Executors.newCachedThreadPool();
+ ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+ try {
+ assertNull(ecs.poll());
+ Callable c = new StringTask();
+ ecs.submit(c);
+ Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
+ if (f != null)
+ assert(f.isDone());
+ } catch (Exception ex) {
+ unexpectedException();
+ } finally {
+ joinPool(e);
+ }
+ }
+
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,665 @@
+/*
+ * 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.math.BigInteger;
+import java.security.*;
+
+public class ExecutorsTest extends JSR166TestCase{
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+ public static Test suite() {
+ return new TestSuite(ExecutorsTest.class);
+ }
+
+ static class TimedCallable<T> implements Callable<T> {
+ private final ExecutorService exec;
+ private final Callable<T> func;
+ private final long msecs;
+
+ TimedCallable(ExecutorService exec, Callable<T> func, long msecs) {
+ this.exec = exec;
+ this.func = func;
+ this.msecs = msecs;
+ }
+
+ public T call() throws Exception {
+ Future<T> ftask = exec.submit(func);
+ try {
+ return ftask.get(msecs, TimeUnit.MILLISECONDS);
+ } finally {
+ ftask.cancel(true);
+ }
+ }
+ }
+
+
+ private static class Fib implements Callable<BigInteger> {
+ private final BigInteger n;
+ Fib(long n) {
+ if (n < 0) throw new IllegalArgumentException("need non-negative arg, but got " + n);
+ this.n = BigInteger.valueOf(n);
+ }
+ public BigInteger call() {
+ BigInteger f1 = BigInteger.ONE;
+ BigInteger f2 = f1;
+ for (BigInteger i = BigInteger.ZERO; i.compareTo(n) < 0; i = i.add(BigInteger.ONE)) {
+ BigInteger t = f1.add(f2);
+ f1 = f2;
+ f2 = t;
+ }
+ return f1;
+ }
+ };
+
+ /**
+ * A newCachedThreadPool can execute runnables
+ */
+ public void testNewCachedThreadPool1() {
+ ExecutorService e = Executors.newCachedThreadPool();
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ joinPool(e);
+ }
+
+ /**
+ * A newCachedThreadPool with given ThreadFactory can execute runnables
+ */
+ public void testNewCachedThreadPool2() {
+ ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ joinPool(e);
+ }
+
+ /**
+ * A newCachedThreadPool with null ThreadFactory throws NPE
+ */
+ public void testNewCachedThreadPool3() {
+ try {
+ ExecutorService e = Executors.newCachedThreadPool(null);
+ shouldThrow();
+ }
+ catch(NullPointerException success) {
+ }
+ }
+
+
+ /**
+ * A new SingleThreadExecutor can execute runnables
+ */
+ public void testNewSingleThreadExecutor1() {
+ ExecutorService e = Executors.newSingleThreadExecutor();
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ joinPool(e);
+ }
+
+ /**
+ * A new SingleThreadExecutor with given ThreadFactory can execute runnables
+ */
+ public void testNewSingleThreadExecutor2() {
+ ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ joinPool(e);
+ }
+
+ /**
+ * A new SingleThreadExecutor with null ThreadFactory throws NPE
+ */
+ public void testNewSingleThreadExecutor3() {
+ try {
+ ExecutorService e = Executors.newSingleThreadExecutor(null);
+ shouldThrow();
+ }
+ catch(NullPointerException success) {
+ }
+ }
+
+ /**
+ * A new SingleThreadExecutor cannot be casted to concrete implementation
+ */
+ public void testCastNewSingleThreadExecutor() {
+ ExecutorService e = Executors.newSingleThreadExecutor();
+ try {
+ ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
+ } catch (ClassCastException success) {
+ } finally {
+ joinPool(e);
+ }
+ }
+
+
+ /**
+ * A new newFixedThreadPool can execute runnables
+ */
+ public void testNewFixedThreadPool1() {
+ ExecutorService e = Executors.newFixedThreadPool(2);
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ joinPool(e);
+ }
+
+ /**
+ * A new newFixedThreadPool with given ThreadFactory can execute runnables
+ */
+ public void testNewFixedThreadPool2() {
+ ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ joinPool(e);
+ }
+
+ /**
+ * A new newFixedThreadPool with null ThreadFactory throws NPE
+ */
+ public void testNewFixedThreadPool3() {
+ try {
+ ExecutorService e = Executors.newFixedThreadPool(2, null);
+ shouldThrow();
+ }
+ catch(NullPointerException success) {
+ }
+ }
+
+ /**
+ * A new newFixedThreadPool with 0 threads throws IAE
+ */
+ public void testNewFixedThreadPool4() {
+ try {
+ ExecutorService e = Executors.newFixedThreadPool(0);
+ shouldThrow();
+ }
+ catch(IllegalArgumentException success) {
+ }
+ }
+
+
+ /**
+ * An unconfigurable newFixedThreadPool can execute runnables
+ */
+ public void testunconfigurableExecutorService() {
+ ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ e.execute(new NoOpRunnable());
+ joinPool(e);
+ }
+
+ /**
+ * unconfigurableExecutorService(null) throws NPE
+ */
+ public void testunconfigurableExecutorServiceNPE() {
+ try {
+ ExecutorService e = Executors.unconfigurableExecutorService(null);
+ }
+ catch (NullPointerException success) {
+ }
+ }
+
+ /**
+ * unconfigurableScheduledExecutorService(null) throws NPE
+ */
+ public void testunconfigurableScheduledExecutorServiceNPE() {
+ try {
+ ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
+ }
+ catch (NullPointerException success) {
+ }
+ }
+
+
+ /**
+ * a newSingleThreadScheduledExecutor successfully runs delayed task
+ */
+ public void testNewSingleThreadScheduledExecutor() {
+ try {
+ TrackedCallable callable = new TrackedCallable();
+ ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
+ Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
+ assertFalse(callable.done);
+ Thread.sleep(MEDIUM_DELAY_MS);
+ assertTrue(callable.done);
+ assertEquals(Boolean.TRUE, f.get());
+ joinPool(p1);
+ } catch(RejectedExecutionException e){}
+ catch(Exception e){
+ e.printStackTrace();
+ unexpectedException();
+ }
+ }
+
+ /**
+ * a newScheduledThreadPool successfully runs delayed task
+ */
+ public void testnewScheduledThreadPool() {
+ try {
+ TrackedCallable callable = new TrackedCallable();
+ ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
+ Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
+ assertFalse(callable.done);
+ Thread.sleep(MEDIUM_DELAY_MS);
+ assertTrue(callable.done);
+ assertEquals(Boolean.TRUE, f.get());
+ joinPool(p1);
+ } catch(RejectedExecutionException e){}
+ catch(Exception e){
+ e.printStackTrace();
+ unexpectedException();
+ }
+ }
+
+ /**
+ * an unconfigurable newScheduledThreadPool successfully runs delayed task
+ */
+ public void testunconfigurableScheduledExecutorService() {
+ try {
+ TrackedCallable callable = new TrackedCallable();
+ ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
+ Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
+ assertFalse(callable.done);
+ Thread.sleep(MEDIUM_DELAY_MS);
+ assertTrue(callable.done);
+ assertEquals(Boolean.TRUE, f.get());
+ joinPool(p1);
+ } catch(RejectedExecutionException e){}
+ catch(Exception e){
+ e.printStackTrace();
+ unexpectedException();
+ }
+ }
+
+ /**
+ * timeouts from execute will time out if they compute too long.
+ */
+ public void testTimedCallable() {
+ int N = 10000;
+ ExecutorService executor = Executors.newSingleThreadExecutor();
+ List<Callable<BigInteger>> tasks = new ArrayList<Callable<BigInteger>>(N);
+ try {
+ long startTime = System.currentTimeMillis();
+
+ long i = 0;
+ while (tasks.size() < N) {
+ tasks.add(new TimedCallable<BigInteger>(executor, new Fib(i), 1));
+ i += 10;
+ }
+
+ int iters = 0;
+ BigInteger sum = BigInteger.ZERO;
+ for (Iterator<Callable<BigInteger>> it = tasks.iterator(); it.hasNext();) {
+ try {
+ ++iters;
+ sum = sum.add(it.next().call());
+ }
+ catch (TimeoutException success) {
+ assertTrue(iters > 0);
+ return;
+ }
+ catch (Exception e) {
+ unexpectedException();
+ }
+ }
+ // if by chance we didn't ever time out, total time must be small
+ long elapsed = System.currentTimeMillis() - startTime;
+ assertTrue(elapsed < N);
+ }
+ finally {
+ joinPool(executor);
+ }
+ }
+
+
+ /**
+ * ThreadPoolExecutor using defaultThreadFactory has
+ * specified group, priority, daemon status, and name
+ */
+ public void testDefaultThreadFactory() {
+ final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
+ Runnable r = new Runnable() {
+ public void run() {
+ try {
+ Thread current = Thread.currentThread();
+ threadAssertTrue(!current.isDaemon());
+ threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
+ ThreadGroup g = current.getThreadGroup();
+ SecurityManager s = System.getSecurityManager();
+ if (s != null)
+ threadAssertTrue(g == s.getThreadGroup());
+ else
+ threadAssertTrue(g == egroup);
+ String name = current.getName();
+ threadAssertTrue(name.endsWith("thread-1"));
+ } catch (SecurityException ok) {
+ // Also pass if not allowed to change setting
+ }
+ }
+ };
+ ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
+
+ e.execute(r);
+ try {
+ e.shutdown();
+ } catch(SecurityException ok) {
+ }
+
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ } catch (Exception eX) {
+ unexpectedException();
+ } finally {
+ joinPool(e);
+ }
+ }
+
+ /**
+ * ThreadPoolExecutor using privilegedThreadFactory has
+ * specified group, priority, daemon status, name,
+ * access control context and context class loader
+ */
+ public void testPrivilegedThreadFactory() {
+ Policy savedPolicy = null;
+ try {
+ savedPolicy = Policy.getPolicy();
+ AdjustablePolicy policy = new AdjustablePolicy();
+ policy.addPermission(new RuntimePermission("getContextClassLoader"));
+ policy.addPermission(new RuntimePermission("setContextClassLoader"));
+ Policy.setPolicy(policy);
+ } catch (AccessControlException ok) {
+ return;
+ }
+ final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
+ final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
+ final AccessControlContext thisacc = AccessController.getContext();
+ Runnable r = new Runnable() {
+ public void run() {
+ try {
+ Thread current = Thread.currentThread();
+ threadAssertTrue(!current.isDaemon());
+ threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
+ ThreadGroup g = current.getThreadGroup();
+ SecurityManager s = System.getSecurityManager();
+ if (s != null)
+ threadAssertTrue(g == s.getThreadGroup());
+ else
+ threadAssertTrue(g == egroup);
+ String name = current.getName();
+ threadAssertTrue(name.endsWith("thread-1"));
+ threadAssertTrue(thisccl == current.getContextClassLoader());
+ threadAssertTrue(thisacc.equals(AccessController.getContext()));
+ } catch(SecurityException ok) {
+ // Also pass if not allowed to change settings
+ }
+ }
+ };
+ ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
+
+ Policy.setPolicy(savedPolicy);
+ e.execute(r);
+ try {
+ e.shutdown();
+ } catch(SecurityException ok) {
+ }
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ } catch (Exception ex) {
+ unexpectedException();
+ } finally {
+ joinPool(e);
+ }
+
+ }
+
+ void checkCCL() {
+ AccessController.getContext().checkPermission(new RuntimePermission("getContextClassLoader"));
+ }
+
+ class CheckCCL implements Callable<Object> {
+ public Object call() {
+ checkCCL();
+ return null;
+ }
+ }
+
+
+ /**
+ * Without class loader permissions, creating
+ * privilegedCallableUsingCurrentClassLoader throws ACE
+ */
+ public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
+ Policy savedPolicy = null;
+ try {
+ savedPolicy = Policy.getPolicy();
+ AdjustablePolicy policy = new AdjustablePolicy();
+ Policy.setPolicy(policy);
+ } catch (AccessControlException ok) {
+ return;
+ }
+
+ // Check if program still has too many permissions to run test
+ try {
+ checkCCL();
+ // too many privileges to test; so return
+ Policy.setPolicy(savedPolicy);
+ return;
+ } catch(AccessControlException ok) {
+ }
+
+ try {
+ Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
+ shouldThrow();
+ } catch(AccessControlException success) {
+ } catch(Exception ex) {
+ unexpectedException();
+ }
+ finally {
+ Policy.setPolicy(savedPolicy);
+ }
+ }
+
+ /**
+ * With class loader permissions, calling
+ * privilegedCallableUsingCurrentClassLoader does not throw ACE
+ */
+ public void testprivilegedCallableUsingCCLWithPrivs() {
+ Policy savedPolicy = null;
+ try {
+ savedPolicy = Policy.getPolicy();
+ AdjustablePolicy policy = new AdjustablePolicy();
+ policy.addPermission(new RuntimePermission("getContextClassLoader"));
+ policy.addPermission(new RuntimePermission("setContextClassLoader"));
+ Policy.setPolicy(policy);
+ } catch (AccessControlException ok) {
+ return;
+ }
+
+ try {
+ Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
+ task.call();
+ } catch(Exception ex) {
+ unexpectedException();
+ }
+ finally {
+ Policy.setPolicy(savedPolicy);
+ }
+ }
+
+ /**
+ * Without permissions, calling privilegedCallable throws ACE
+ */
+ public void testprivilegedCallableWithNoPrivs() {
+ Callable task;
+ Policy savedPolicy = null;
+ AdjustablePolicy policy = null;
+ AccessControlContext noprivAcc = null;
+ try {
+ savedPolicy = Policy.getPolicy();
+ policy = new AdjustablePolicy();
+ Policy.setPolicy(policy);
+ noprivAcc = AccessController.getContext();
+ task = Executors.privilegedCallable(new CheckCCL());
+ Policy.setPolicy(savedPolicy);
+ } catch (AccessControlException ok) {
+ return; // program has too few permissions to set up test
+ }
+
+ // Make sure that program doesn't have too many permissions
+ try {
+ AccessController.doPrivileged(new PrivilegedAction() {
+ public Object run() {
+ checkCCL();
+ return null;
+ }}, noprivAcc);
+ // too many permssions; skip test
+ return;
+ } catch(AccessControlException ok) {
+ }
+
+ try {
+ task.call();
+ shouldThrow();
+ } catch(AccessControlException success) {
+ } catch(Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * With permissions, calling privilegedCallable succeeds
+ */
+ public void testprivilegedCallableWithPrivs() {
+ Policy savedPolicy = null;
+ try {
+ savedPolicy = Policy.getPolicy();
+ AdjustablePolicy policy = new AdjustablePolicy();
+ policy.addPermission(new RuntimePermission("getContextClassLoader"));
+ policy.addPermission(new RuntimePermission("setContextClassLoader"));
+ Policy.setPolicy(policy);
+ } catch (AccessControlException ok) {
+ return;
+ }
+
+ Callable task = Executors.privilegedCallable(new CheckCCL());
+ try {
+ task.call();
+ } catch(Exception ex) {
+ unexpectedException();
+ } finally {
+ Policy.setPolicy(savedPolicy);
+ }
+ }
+
+ /**
+ * callable(Runnable) returns null when called
+ */
+ public void testCallable1() {
+ try {
+ Callable c = Executors.callable(new NoOpRunnable());
+ assertNull(c.call());
+ } catch(Exception ex) {
+ unexpectedException();
+ }
+
+ }
+
+ /**
+ * callable(Runnable, result) returns result when called
+ */
+ public void testCallable2() {
+ try {
+ Callable c = Executors.callable(new NoOpRunnable(), one);
+ assertEquals(one, c.call());
+ } catch(Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * callable(PrivilegedAction) returns its result when called
+ */
+ public void testCallable3() {
+ try {
+ Callable c = Executors.callable(new PrivilegedAction() {
+ public Object run() { return one; }});
+ assertEquals(one, c.call());
+ } catch(Exception ex) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * callable(PrivilegedExceptionAction) returns its result when called
+ */
+ public void testCallable4() {
+ try {
+ Callable c = Executors.callable(new PrivilegedExceptionAction() {
+ public Object run() { return one; }});
+ assertEquals(one, c.call());
+ } catch(Exception ex) {
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * callable(null Runnable) throws NPE
+ */
+ public void testCallableNPE1() {
+ try {
+ Runnable r = null;
+ Callable c = Executors.callable(r);
+ } catch (NullPointerException success) {
+ }
+ }
+
+ /**
+ * callable(null, result) throws NPE
+ */
+ public void testCallableNPE2() {
+ try {
+ Runnable r = null;
+ Callable c = Executors.callable(r, one);
+ } catch (NullPointerException success) {
+ }
+ }
+
+ /**
+ * callable(null PrivilegedAction) throws NPE
+ */
+ public void testCallableNPE3() {
+ try {
+ PrivilegedAction r = null;
+ Callable c = Executors.callable(r);
+ } catch (NullPointerException success) {
+ }
+ }
+
+ /**
+ * callable(null PrivilegedExceptionAction) throws NPE
+ */
+ public void testCallableNPE4() {
+ try {
+ PrivilegedExceptionAction r = null;
+ Callable c = Executors.callable(r);
+ } catch (NullPointerException success) {
+ }
+ }
+
+
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,474 @@
+/*
+ * 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.*;
+import java.util.*;
+
+public class FutureTaskTest extends JSR166TestCase {
+
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run (suite());
+ }
+ public static Test suite() {
+ return new TestSuite(FutureTaskTest.class);
+ }
+
+ /**
+ * Subclass to expose protected methods
+ */
+ static class PublicFutureTask extends FutureTask {
+ public PublicFutureTask(Callable r) { super(r); }
+ public boolean runAndReset() { return super.runAndReset(); }
+ public void set(Object x) { super.set(x); }
+ public void setException(Throwable t) { super.setException(t); }
+ }
+
+ /**
+ * Creating a future with a null callable throws NPE
+ */
+ public void testConstructor() {
+ try {
+ FutureTask task = new FutureTask(null);
+ shouldThrow();
+ }
+ catch(NullPointerException success) {
+ }
+ }
+
+ /**
+ * creating a future with null runnable fails
+ */
+ public void testConstructor2() {
+ try {
+ FutureTask task = new FutureTask(null, Boolean.TRUE);
+ shouldThrow();
+ }
+ catch(NullPointerException success) {
+ }
+ }
+
+ /**
+ * isDone is true when a task completes
+ */
+ public void testIsDone() {
+ FutureTask task = new FutureTask( new NoOpCallable());
+ task.run();
+ assertTrue(task.isDone());
+ assertFalse(task.isCancelled());
+ }
+
+ /**
+ * runAndReset of a non-cancelled task succeeds
+ */
+ public void testRunAndReset() {
+ PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
+ assertTrue(task.runAndReset());
+ assertFalse(task.isDone());
+ }
+
+ /**
+ * runAndReset after cancellation fails
+ */
+ public void testResetAfterCancel() {
+ PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
+ assertTrue(task.cancel(false));
+ assertFalse(task.runAndReset());
+ assertTrue(task.isDone());
+ assertTrue(task.isCancelled());
+ }
+
+
+
+ /**
+ * setting value causes get to return it
+ */
+ public void testSet() {
+ PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
+ task.set(one);
+ try {
+ assertEquals(task.get(), one);
+ }
+ catch(Exception e) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * setException causes get to throw ExecutionException
+ */
+ public void testSetException() {
+ Exception nse = new NoSuchElementException();
+ PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
+ task.setException(nse);
+ try {
+ Object x = task.get();
+ shouldThrow();
+ }
+ catch(ExecutionException ee) {
+ Throwable cause = ee.getCause();
+ assertEquals(cause, nse);
+ }
+ catch(Exception e) {
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Cancelling before running succeeds
+ */
+ public void testCancelBeforeRun() {
+ FutureTask task = new FutureTask( new NoOpCallable());
+ assertTrue(task.cancel(false));
+ task.run();
+ assertTrue(task.isDone());
+ assertTrue(task.isCancelled());
+ }
+
+ /**
+ * Cancel(true) before run succeeds
+ */
+ public void testCancelBeforeRun2() {
+ FutureTask task = new FutureTask( new NoOpCallable());
+ assertTrue(task.cancel(true));
+ task.run();
+ assertTrue(task.isDone());
+ assertTrue(task.isCancelled());
+ }
+
+ /**
+ * cancel of a completed task fails
+ */
+ public void testCancelAfterRun() {
+ FutureTask task = new FutureTask( new NoOpCallable());
+ task.run();
+ assertFalse(task.cancel(false));
+ assertTrue(task.isDone());
+ assertFalse(task.isCancelled());
+ }
+
+ /**
+ * cancel(true) interrupts a running task
+ */
+ public void testCancelInterrupt() {
+ FutureTask task = new FutureTask( new Callable() {
+ public Object call() {
+ try {
+ Thread.sleep(MEDIUM_DELAY_MS);
+ threadShouldThrow();
+ }
+ catch (InterruptedException success) {}
+ return Boolean.TRUE;
+ } });
+ Thread t = new Thread(task);
+ t.start();
+
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(task.cancel(true));
+ t.join();
+ assertTrue(task.isDone());
+ assertTrue(task.isCancelled());
+ } catch(InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * cancel(false) does not interrupt a running task
+ */
+ public void testCancelNoInterrupt() {
+ FutureTask task = new FutureTask( new Callable() {
+ public Object call() {
+ try {
+ Thread.sleep(MEDIUM_DELAY_MS);
+ }
+ catch (InterruptedException success) {
+ threadFail("should not interrupt");
+ }
+ return Boolean.TRUE;
+ } });
+ Thread t = new Thread(task);
+ t.start();
+
+ try {
+ Thread.sleep(SHORT_DELAY_MS);
+ assertTrue(task.cancel(false));
+ t.join();
+ assertTrue(task.isDone());
+ assertTrue(task.isCancelled());
+ } catch(InterruptedException e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * set in one thread causes get in another thread to retrieve value
+ */
+ public void testGet1() {
+ final FutureTask ft = new FutureTask(new Callable() {
+ public Object call() {
+ try {
+ Thread.sleep(MEDIUM_DELAY_MS);
+ } catch(InterruptedException e){
+ threadUnexpectedException();
+ }
+ return Boolean.TRUE;
+ }
+ });
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ ft.get();
+ } catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ assertFalse(ft.isDone());
+ assertFalse(ft.isCancelled());
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ ft.run();
+ t.join();
+ assertTrue(ft.isDone());
+ assertFalse(ft.isCancelled());
+ } catch(InterruptedException e){
+ unexpectedException();
+
+ }
+ }
+
+ /**
+ * set in one thread causes timed get in another thread to retrieve value
+ */
+ public void testTimedGet1() {
+ final FutureTask ft = new FutureTask(new Callable() {
+ public Object call() {
+ try {
+ Thread.sleep(MEDIUM_DELAY_MS);
+ } catch(InterruptedException e){
+ threadUnexpectedException();
+ }
+ return Boolean.TRUE;
+ }
+ });
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
+ } catch(TimeoutException success) {
+ } catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ assertFalse(ft.isDone());
+ assertFalse(ft.isCancelled());
+ t.start();
+ ft.run();
+ t.join();
+ assertTrue(ft.isDone());
+ assertFalse(ft.isCancelled());
+ } catch(InterruptedException e){
+ unexpectedException();
+
+ }
+ }
+
+ /**
+ * Cancelling a task causes timed get in another thread to throw CancellationException
+ */
+ public void testTimedGet_Cancellation() {
+ final FutureTask ft = new FutureTask(new Callable() {
+ public Object call() {
+ try {
+ Thread.sleep(SMALL_DELAY_MS);
+ threadShouldThrow();
+ } catch(InterruptedException e) {
+ }
+ return Boolean.TRUE;
+ }
+ });
+ try {
+ Thread t1 = new Thread(new Runnable() {
+ public void run() {
+ try {
+ ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
+ threadShouldThrow();
+ } catch(CancellationException success) {}
+ catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ Thread t2 = new Thread(ft);
+ t1.start();
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ ft.cancel(true);
+ t1.join();
+ t2.join();
+ } catch(InterruptedException ie){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Cancelling a task causes get in another thread to throw CancellationException
+ */
+ public void testGet_Cancellation() {
+ final FutureTask ft = new FutureTask(new Callable() {
+ public Object call() {
+ try {
+ Thread.sleep(MEDIUM_DELAY_MS);
+ threadShouldThrow();
+ } catch(InterruptedException e){
+ }
+ return Boolean.TRUE;
+ }
+ });
+ try {
+ Thread t1 = new Thread(new Runnable() {
+ public void run() {
+ try {
+ ft.get();
+ threadShouldThrow();
+ } catch(CancellationException success){
+ }
+ catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ Thread t2 = new Thread(ft);
+ t1.start();
+ t2.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ ft.cancel(true);
+ t1.join();
+ t2.join();
+ } catch(InterruptedException success){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * A runtime exception in task causes get to throw ExecutionException
+ */
+ public void testGet_ExecutionException() {
+ final FutureTask ft = new FutureTask(new Callable() {
+ public Object call() {
+ int i = 5/0;
+ return Boolean.TRUE;
+ }
+ });
+ try {
+ ft.run();
+ ft.get();
+ shouldThrow();
+ } catch(ExecutionException success){
+ }
+ catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * A runtime exception in task causes timed get to throw ExecutionException
+ */
+ public void testTimedGet_ExecutionException2() {
+ final FutureTask ft = new FutureTask(new Callable() {
+ public Object call() {
+ int i = 5/0;
+ return Boolean.TRUE;
+ }
+ });
+ try {
+ ft.run();
+ ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
+ shouldThrow();
+ } catch(ExecutionException success) {
+ } catch(TimeoutException success) { } // unlikely but OK
+ catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+
+ /**
+ * Interrupting a waiting get causes it to throw InterruptedException
+ */
+ public void testGet_InterruptedException() {
+ final FutureTask ft = new FutureTask(new NoOpCallable());
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ ft.get();
+ threadShouldThrow();
+ } catch(InterruptedException success){
+ } catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * Interrupting a waiting timed get causes it to throw InterruptedException
+ */
+ public void testTimedGet_InterruptedException2() {
+ final FutureTask ft = new FutureTask(new NoOpCallable());
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS);
+ threadShouldThrow();
+ } catch(InterruptedException success){}
+ catch(Exception e){
+ threadUnexpectedException();
+ }
+ }
+ });
+ try {
+ t.start();
+ Thread.sleep(SHORT_DELAY_MS);
+ t.interrupt();
+ t.join();
+ } catch(Exception e){
+ unexpectedException();
+ }
+ }
+
+ /**
+ * A timed out timed get throws TimeoutException
+ */
+ public void testGet_TimeoutException() {
+ try {
+ FutureTask ft = new FutureTask(new NoOpCallable());
+ ft.get(1,TimeUnit.MILLISECONDS);
+ shouldThrow();
+ } catch(TimeoutException success){}
+ catch(Exception success){
+ unexpectedException();
+ }
+ }
+
+}
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java
------------------------------------------------------------------------------
svn:eol-style = native