harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ndbe...@apache.org
Subject svn commit: r442038 [14/19] - in /incubator/harmony/standard/classlib/trunk/modules/concurrent: ./ src/ src/main/ src/main/java/ src/main/java/java/ src/main/java/java/util/ src/main/java/java/util/concurrent/ src/main/java/java/util/concurrent/atomic/...
Date Sun, 10 Sep 2006 23:59:35 GMT
Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java Sun Sep 10 16:59:30 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/standard/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java Sun Sep 10 16:59:30 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/standard/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java Sun Sep 10 16:59:30 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/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java Sun Sep 10 16:59:30 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/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java Sun Sep 10 16:59:30 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/standard/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message