test/tck/ArrayBlockingQueueTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, Mike Judd.
 */

import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;
import java.io.*;

public class ArrayBlockingQueueTest extends JSR166TestCase {

    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }

    public static Test suite() {
        return new TestSuite(ArrayBlockingQueueTest.class);
    }

    /**
     * Create a queue of given size containing consecutive
     * Integers 0 ... n.
     */
    private ArrayBlockingQueue populatedQueue(int n) {
        ArrayBlockingQueue q = new ArrayBlockingQueue(n);
        assertTrue(q.isEmpty());
        for(int i = 0; i < n; i++)
            assertTrue(q.offer(new Integer(i)));
        assertFalse(q.isEmpty());
        assertEquals(0, q.remainingCapacity());
        assertEquals(n, q.size());
        return q;
    }
 
    public void testConstructor1(){
        assertEquals(SIZE, new ArrayBlockingQueue(SIZE).remainingCapacity());
    }

    public void testConstructor2(){
        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(0);
            fail("Cannot make zero-sized");
        }
        catch (IllegalArgumentException success) {}
    }

    public void testConstructor3(){

        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);
            fail("Cannot make from null collection");
        }
        catch (NullPointerException success) {}
    }

    public void testConstructor4(){
        try {
            Integer[] ints = new Integer[SIZE];
            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
            fail("Cannot make with null elements");
        }
        catch (NullPointerException success) {}
    }

    public void testConstructor5(){
        try {
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE-1; ++i)
                ints[i] = new Integer(i);
            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
            fail("Cannot make with null elements");
        }
        catch (NullPointerException success) {}
    }

    public void testConstructor6(){
        try {
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE; ++i)
                ints[i] = new Integer(i);
            ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));
            fail("Cannot make with insufficient capacity");
        }
        catch (IllegalArgumentException success) {}
    }

    public void testConstructor7(){
        try {
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE; ++i)
                ints[i] = new Integer(i);
            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));
            for (int i = 0; i < SIZE; ++i)
                assertEquals(ints[i], q.poll());
        }
        finally {}
    }

    public void testEmptyFull() {
        ArrayBlockingQueue q = new ArrayBlockingQueue(2);
        assertTrue(q.isEmpty());
        assertEquals("should have room for 2", 2, q.remainingCapacity());
        q.add(one);
        assertFalse(q.isEmpty());
        q.add(two);
        assertFalse(q.isEmpty());
        assertEquals("queue should be full", 0, q.remainingCapacity());
        assertFalse("offer should be rejected", q.offer(three));
    }

    public void testRemainingCapacity(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, q.remainingCapacity());
            assertEquals(SIZE-i, q.size());
            q.remove();
        }
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(SIZE-i, q.remainingCapacity());
            assertEquals(i, q.size());
            q.add(new Integer(i));
        }
    }

    public void testOfferNull(){
        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(1);
            q.offer(null);
            fail("should throw NPE");
        } catch (NullPointerException success) { }   
    }

    public void testOffer(){
        ArrayBlockingQueue q = new ArrayBlockingQueue(1);
        assertTrue(q.offer(zero));
        assertFalse(q.offer(one));
    }

    public void testAdd(){
        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
            for (int i = 0; i < SIZE; ++i) {
                assertTrue(q.add(new Integer(i)));
            }
            assertEquals(0, q.remainingCapacity());
            q.add(new Integer(SIZE));
        } catch (IllegalStateException success){
        }   
    }

    public void testAddAll1(){
        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(1);
            q.addAll(null);
            fail("Cannot add null collection");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll2(){
        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
            Integer[] ints = new Integer[SIZE];
            q.addAll(Arrays.asList(ints));
            fail("Cannot add null elements");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll3(){
        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE-1; ++i)
                ints[i] = new Integer(i);
            q.addAll(Arrays.asList(ints));
            fail("Cannot add null elements");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll4(){
        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(1);
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE; ++i)
                ints[i] = new Integer(i);
            q.addAll(Arrays.asList(ints));
            fail("Cannot add with insufficient capacity");
        }
        catch (IllegalStateException success) {}
    }
    public void testAddAll5(){
        try {
            Integer[] empty = new Integer[0];
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE; ++i)
                ints[i] = new Integer(i);
            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
            assertFalse(q.addAll(Arrays.asList(empty)));
            assertTrue(q.addAll(Arrays.asList(ints)));
            for (int i = 0; i < SIZE; ++i)
                assertEquals(ints[i], q.poll());
        }
        finally {}
    }

     public void testPutNull() {
        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
            q.put(null);
            fail("put should throw NPE");
        } 
        catch (NullPointerException success){
        }   
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
     }

     public void testPut() {
         try {
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
             for (int i = 0; i < SIZE; ++i) {
                 Integer I = new Integer(i);
                 q.put(I);
                 assertTrue(q.contains(I));
             }
             assertEquals(0, q.remainingCapacity());
         }
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
    }

    public void testBlockingPut(){
        Thread t = new Thread(new Runnable() {
                public void run() {
                    int added = 0;
                    try {
                        ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
                        for (int i = 0; i < SIZE; ++i) {
                            q.put(new Integer(i));
                            ++added;
                        }
                        q.put(new Integer(SIZE));
                        threadFail("put should block");
                    } catch (InterruptedException ie){
                        threadAssertEquals(added, SIZE);
                    }   
                }});
        try { 
            t.start();
           Thread.sleep(SHORT_DELAY_MS); 
           t.interrupt();
           t.join();
        }
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
    }

    public void testPutWithTake() {
        final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
        Thread t = new Thread(new Runnable() {
                public void run(){
                    int added = 0;
                    try {
                        q.put(new Object());
                        ++added;
                        q.put(new Object());
                        ++added;
                        q.put(new Object());
                        ++added;
                        q.put(new Object());
                        ++added;
                        threadFail("Should block");
                    } catch (InterruptedException e){
                        threadAssertTrue(added >= 2);
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            q.take();
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }

    public void testTimedOffer() {
        final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        q.put(new Object());
                        q.put(new Object());
                        threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
                        q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadFail("Should block");
                    } catch (InterruptedException success){}
                }
            });
        
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }

    public void testTake(){
        try {
            ArrayBlockingQueue q = populatedQueue(SIZE);
            for (int i = 0; i < SIZE; ++i) {
                assertEquals(i, ((Integer)q.take()).intValue());
            }
        } catch (InterruptedException e){
            fail("Unexpected exception");
        }   
    }

    public void testTakeFromEmpty() {
        final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        q.take();
                        threadFail("Should block");
                    } catch (InterruptedException success){ }                
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }

    public void testBlockingTake(){
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        ArrayBlockingQueue q = populatedQueue(SIZE);
                        for (int i = 0; i < SIZE; ++i) {
                            threadAssertEquals(i, ((Integer)q.take()).intValue());
                        }
                        q.take();
                        threadFail("take should block");
                    } catch (InterruptedException success){
                    }   
                }});
        try { 
            t.start();
            Thread.sleep(SHORT_DELAY_MS); 
            t.interrupt();
            t.join();
        }
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
    }


    public void testPoll(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.poll()).intValue());
        }
        assertNull(q.poll());
    }

    public void testTimedPoll0() {
        try {
            ArrayBlockingQueue q = populatedQueue(SIZE);
            for (int i = 0; i < SIZE; ++i) {
                assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());
            }
            assertNull(q.poll(0, TimeUnit.MILLISECONDS));
        } catch (InterruptedException e){
            fail("Unexpected exception");
        }   
    }

    public void testTimedPoll() {
        try {
            ArrayBlockingQueue q = populatedQueue(SIZE);
            for (int i = 0; i < SIZE; ++i) {
                assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
            }
            assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
        } catch (InterruptedException e){
            fail("Unexpected exception");
        }   
    }

    public void testInterruptedTimedPoll(){
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        ArrayBlockingQueue q = populatedQueue(SIZE);
                        for (int i = 0; i < SIZE; ++i) {
                            threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
                        }
                        threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                    } catch (InterruptedException success){
                    }   
                }});
        try { 
            t.start();
            Thread.sleep(SHORT_DELAY_MS); 
            t.interrupt();
            t.join();
        }
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
    }

    public void testTimedPollWithOffer(){
        final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadFail("Should block");
                    } catch (InterruptedException success) { }                
                }
            });
        try {
            t.start();
            Thread.sleep(SMALL_DELAY_MS);
            assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }  


    public void testPeek(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.peek()).intValue());
            q.poll();
            assertTrue(q.peek() == null ||
                       i != ((Integer)q.peek()).intValue());
        }
        assertNull(q.peek());
    }

    public void testElement(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.element()).intValue());
            q.poll();
        }
        try {
            q.element();
            fail("no such element");
        }
        catch (NoSuchElementException success) {}
    }

    public void testRemove(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.remove()).intValue());
        }
        try {
            q.remove();
            fail("remove should throw");
        } catch (NoSuchElementException success){
        }   
    }

    public void testRemoveElement(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        for (int i = 1; i < SIZE; i+=2) {
            assertTrue(q.remove(new Integer(i)));
        }
        for (int i = 0; i < SIZE; i+=2) {
            assertTrue(q.remove(new Integer(i)));
            assertFalse(q.remove(new Integer(i+1)));
        }
        assertTrue(q.isEmpty());
    }
        
    public void testContains(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertTrue(q.contains(new Integer(i)));
            q.poll();
            assertFalse(q.contains(new Integer(i)));
        }
    }

    public void testClear(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        q.clear();
        assertTrue(q.isEmpty());
        assertEquals(0, q.size());
        assertEquals(SIZE, q.remainingCapacity());
        q.add(one);
        assertFalse(q.isEmpty());
        q.clear();
        assertTrue(q.isEmpty());
    }

    public void testContainsAll(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        ArrayBlockingQueue p = new ArrayBlockingQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertTrue(q.containsAll(p));
            assertFalse(p.containsAll(q));
            p.add(new Integer(i));
        }
        assertTrue(p.containsAll(q));
    }

    public void testRetainAll(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        ArrayBlockingQueue p = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            boolean changed = q.retainAll(p);
            if (i == 0)
                assertFalse(changed);
            else
                assertTrue(changed);

            assertTrue(q.containsAll(p));
            assertEquals(SIZE-i, q.size());
            p.remove();
        }
    }

    public void testRemoveAll(){
        for (int i = 1; i < SIZE; ++i) {
            ArrayBlockingQueue q = populatedQueue(SIZE);
            ArrayBlockingQueue p = populatedQueue(i);
            assertTrue(q.removeAll(p));
            assertEquals(SIZE-i, q.size());
            for (int j = 0; j < i; ++j) {
                Integer I = (Integer)(p.remove());
                assertFalse(q.contains(I));
            }
        }
    }


    public void testToArray(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        Object[] o = q.toArray();
        try {
        for(int i = 0; i < o.length; i++)
            assertEquals(o[i], q.take());
        } catch (InterruptedException e){
            fail("Unexpected exception");
        }    
    }

    public void testToArray2(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        Integer[] ints = new Integer[SIZE];
        ints = (Integer[])q.toArray(ints);
        try {
            for(int i = 0; i < ints.length; i++)
                assertEquals(ints[i], q.take());
        } catch (InterruptedException e){
            fail("Unexpected exception");
        }    
    }
    
    public void testIterator(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        Iterator it = q.iterator();
        try {
            while(it.hasNext()){
                assertEquals(it.next(), q.take());
            }
        } catch (InterruptedException e){
            fail("Unexpected exception");
        }    
    }

    public void testIteratorOrdering() {

        final ArrayBlockingQueue q = new ArrayBlockingQueue(3);

        q.add(one);
        q.add(two);
        q.add(three);

        assertEquals("queue should be full", 0, q.remainingCapacity());

        int k = 0;
        for (Iterator it = q.iterator(); it.hasNext();) {
            int i = ((Integer)(it.next())).intValue();
            assertEquals("items should come out in order", ++k, i);
        }

        assertEquals("should go through 3 elements", 3, k);
    }

    public void testWeaklyConsistentIteration () {

        final ArrayBlockingQueue q = new ArrayBlockingQueue(3);

        q.add(one);
        q.add(two);
        q.add(three);

        try {
            for (Iterator it = q.iterator(); it.hasNext();) {
                q.remove();
                it.next();
            }
        }
        catch (ConcurrentModificationException e) {
            fail("weakly consistent iterator; should not get CME");
        }

        assertEquals("queue should be empty again", 0, q.size());
    }


    public void testToString(){
        ArrayBlockingQueue q = populatedQueue(SIZE);
        String s = q.toString();
        for (int i = 0; i < SIZE; ++i) {
            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
        }
    }        


    public void testOfferInExecutor() {

        final ArrayBlockingQueue q = new ArrayBlockingQueue(2);

        q.add(one);
        q.add(two);

        ExecutorService executor = Executors.newFixedThreadPool(2);

        executor.execute(new Runnable() {
            public void run() {
                threadAssertFalse(q.offer(three));
                try {
                    threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
                    threadAssertEquals(0, q.remainingCapacity());
                }
                catch (InterruptedException e) {
                    threadFail("should not be interrupted");
                }
            }
        });

        executor.execute(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(SMALL_DELAY_MS);
                    threadAssertEquals(one, q.take());
                }
                catch (InterruptedException e) {
                    threadFail("should not be interrupted");
                }
            }
        });
        
        joinPool(executor);

    }

    public void testPollInExecutor() {

        final ArrayBlockingQueue q = new ArrayBlockingQueue(2);

        ExecutorService executor = Executors.newFixedThreadPool(2);

        executor.execute(new Runnable() {
            public void run() {
                threadAssertNull(q.poll());
                try {
                    threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
                    threadAssertTrue(q.isEmpty());
                }
                catch (InterruptedException e) {
                    threadFail("should not be interrupted");
                }
            }
        });

        executor.execute(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(SMALL_DELAY_MS);
                    q.put(one);
                }
                catch (InterruptedException e) {
                    threadFail("should not be interrupted");
                }
            }
        });
        
        joinPool(executor);

    }

    public void testSerialization() {
        ArrayBlockingQueue q = populatedQueue(SIZE);

        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
            out.writeObject(q);
            out.close();

            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
            ArrayBlockingQueue r = (ArrayBlockingQueue)in.readObject();
            assertEquals(q.size(), r.size());
            while (!q.isEmpty()) 
                assertEquals(q.remove(), r.remove());
        } catch(Exception e){
            fail("unexpected exception");
        }
    }


}
Revision:	1.3
Committed:	Sun Sep 14 20:42:40 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.2:	+136 -141 lines
Log Message:	New base class JSR166TestCase
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by members of JCP JSR-166 Expert Group and released to the
3			* public domain. Use, modify, and redistribute this code in any way
4			* without acknowledgement. Other contributors include Andrew Wright,
5			* Jeffrey Hayes, Pat Fischer, Mike Judd.
6			*/
7
8			import junit.framework.*;
9			import java.util.*;
10			import java.util.concurrent.*;
11	dl	1.2	import java.io.*;
12	dl	1.1
13	dl	1.3	public class ArrayBlockingQueueTest extends JSR166TestCase {
14	dl	1.1
15			public static void main(String[] args) {
16			junit.textui.TestRunner.run (suite());
17			}
18
19			public static Test suite() {
20			return new TestSuite(ArrayBlockingQueueTest.class);
21			}
22
23			/**
24			* Create a queue of given size containing consecutive
25			* Integers 0 ... n.
26			*/
27	dl	1.3	private ArrayBlockingQueue populatedQueue(int n) {
28	dl	1.1	ArrayBlockingQueue q = new ArrayBlockingQueue(n);
29			assertTrue(q.isEmpty());
30			for(int i = 0; i < n; i++)
31			assertTrue(q.offer(new Integer(i)));
32			assertFalse(q.isEmpty());
33			assertEquals(0, q.remainingCapacity());
34			assertEquals(n, q.size());
35			return q;
36			}
37
38			public void testConstructor1(){
39	dl	1.3	assertEquals(SIZE, new ArrayBlockingQueue(SIZE).remainingCapacity());
40	dl	1.1	}
41
42			public void testConstructor2(){
43			try {
44			ArrayBlockingQueue q = new ArrayBlockingQueue(0);
45			fail("Cannot make zero-sized");
46			}
47			catch (IllegalArgumentException success) {}
48			}
49
50			public void testConstructor3(){
51
52			try {
53			ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);
54			fail("Cannot make from null collection");
55			}
56			catch (NullPointerException success) {}
57			}
58
59			public void testConstructor4(){
60			try {
61	dl	1.3	Integer[] ints = new Integer[SIZE];
62			ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
63	dl	1.1	fail("Cannot make with null elements");
64			}
65			catch (NullPointerException success) {}
66			}
67
68			public void testConstructor5(){
69			try {
70	dl	1.3	Integer[] ints = new Integer[SIZE];
71			for (int i = 0; i < SIZE-1; ++i)
72	dl	1.1	ints[i] = new Integer(i);
73	dl	1.3	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
74	dl	1.1	fail("Cannot make with null elements");
75			}
76			catch (NullPointerException success) {}
77			}
78
79			public void testConstructor6(){
80			try {
81	dl	1.3	Integer[] ints = new Integer[SIZE];
82			for (int i = 0; i < SIZE; ++i)
83	dl	1.1	ints[i] = new Integer(i);
84			ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));
85			fail("Cannot make with insufficient capacity");
86			}
87			catch (IllegalArgumentException success) {}
88			}
89
90			public void testConstructor7(){
91			try {
92	dl	1.3	Integer[] ints = new Integer[SIZE];
93			for (int i = 0; i < SIZE; ++i)
94	dl	1.1	ints[i] = new Integer(i);
95	dl	1.3	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));
96			for (int i = 0; i < SIZE; ++i)
97	dl	1.1	assertEquals(ints[i], q.poll());
98			}
99			finally {}
100			}
101
102			public void testEmptyFull() {
103			ArrayBlockingQueue q = new ArrayBlockingQueue(2);
104			assertTrue(q.isEmpty());
105			assertEquals("should have room for 2", 2, q.remainingCapacity());
106	dl	1.3	q.add(one);
107	dl	1.1	assertFalse(q.isEmpty());
108	dl	1.3	q.add(two);
109	dl	1.1	assertFalse(q.isEmpty());
110			assertEquals("queue should be full", 0, q.remainingCapacity());
111	dl	1.3	assertFalse("offer should be rejected", q.offer(three));
112	dl	1.1	}
113
114			public void testRemainingCapacity(){
115	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
116			for (int i = 0; i < SIZE; ++i) {
117	dl	1.1	assertEquals(i, q.remainingCapacity());
118	dl	1.3	assertEquals(SIZE-i, q.size());
119	dl	1.1	q.remove();
120			}
121	dl	1.3	for (int i = 0; i < SIZE; ++i) {
122			assertEquals(SIZE-i, q.remainingCapacity());
123	dl	1.1	assertEquals(i, q.size());
124			q.add(new Integer(i));
125			}
126			}
127
128			public void testOfferNull(){
129			try {
130			ArrayBlockingQueue q = new ArrayBlockingQueue(1);
131			q.offer(null);
132			fail("should throw NPE");
133			} catch (NullPointerException success) { }
134			}
135
136			public void testOffer(){
137			ArrayBlockingQueue q = new ArrayBlockingQueue(1);
138	dl	1.3	assertTrue(q.offer(zero));
139			assertFalse(q.offer(one));
140	dl	1.1	}
141
142			public void testAdd(){
143			try {
144	dl	1.3	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
145			for (int i = 0; i < SIZE; ++i) {
146	dl	1.1	assertTrue(q.add(new Integer(i)));
147			}
148			assertEquals(0, q.remainingCapacity());
149	dl	1.3	q.add(new Integer(SIZE));
150	dl	1.1	} catch (IllegalStateException success){
151			}
152			}
153
154			public void testAddAll1(){
155			try {
156			ArrayBlockingQueue q = new ArrayBlockingQueue(1);
157			q.addAll(null);
158			fail("Cannot add null collection");
159			}
160			catch (NullPointerException success) {}
161			}
162			public void testAddAll2(){
163			try {
164	dl	1.3	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
165			Integer[] ints = new Integer[SIZE];
166	dl	1.1	q.addAll(Arrays.asList(ints));
167			fail("Cannot add null elements");
168			}
169			catch (NullPointerException success) {}
170			}
171			public void testAddAll3(){
172			try {
173	dl	1.3	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
174			Integer[] ints = new Integer[SIZE];
175			for (int i = 0; i < SIZE-1; ++i)
176	dl	1.1	ints[i] = new Integer(i);
177			q.addAll(Arrays.asList(ints));
178			fail("Cannot add null elements");
179			}
180			catch (NullPointerException success) {}
181			}
182			public void testAddAll4(){
183			try {
184			ArrayBlockingQueue q = new ArrayBlockingQueue(1);
185	dl	1.3	Integer[] ints = new Integer[SIZE];
186			for (int i = 0; i < SIZE; ++i)
187	dl	1.1	ints[i] = new Integer(i);
188			q.addAll(Arrays.asList(ints));
189			fail("Cannot add with insufficient capacity");
190			}
191			catch (IllegalStateException success) {}
192			}
193			public void testAddAll5(){
194			try {
195			Integer[] empty = new Integer[0];
196	dl	1.3	Integer[] ints = new Integer[SIZE];
197			for (int i = 0; i < SIZE; ++i)
198	dl	1.1	ints[i] = new Integer(i);
199	dl	1.3	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
200	dl	1.1	assertFalse(q.addAll(Arrays.asList(empty)));
201			assertTrue(q.addAll(Arrays.asList(ints)));
202	dl	1.3	for (int i = 0; i < SIZE; ++i)
203	dl	1.1	assertEquals(ints[i], q.poll());
204			}
205			finally {}
206			}
207
208			public void testPutNull() {
209			try {
210	dl	1.3	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
211	dl	1.1	q.put(null);
212			fail("put should throw NPE");
213			}
214			catch (NullPointerException success){
215			}
216			catch (InterruptedException ie) {
217			fail("Unexpected exception");
218			}
219			}
220
221			public void testPut() {
222			try {
223	dl	1.3	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
224			for (int i = 0; i < SIZE; ++i) {
225	dl	1.1	Integer I = new Integer(i);
226			q.put(I);
227			assertTrue(q.contains(I));
228			}
229			assertEquals(0, q.remainingCapacity());
230			}
231			catch (InterruptedException ie) {
232			fail("Unexpected exception");
233			}
234			}
235
236			public void testBlockingPut(){
237			Thread t = new Thread(new Runnable() {
238			public void run() {
239			int added = 0;
240			try {
241	dl	1.3	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
242			for (int i = 0; i < SIZE; ++i) {
243	dl	1.1	q.put(new Integer(i));
244			++added;
245			}
246	dl	1.3	q.put(new Integer(SIZE));
247			threadFail("put should block");
248	dl	1.1	} catch (InterruptedException ie){
249	dl	1.3	threadAssertEquals(added, SIZE);
250	dl	1.1	}
251			}});
252			try {
253	dl	1.3	t.start();
254	dl	1.1	Thread.sleep(SHORT_DELAY_MS);
255			t.interrupt();
256			t.join();
257			}
258			catch (InterruptedException ie) {
259			fail("Unexpected exception");
260			}
261			}
262
263			public void testPutWithTake() {
264			final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
265			Thread t = new Thread(new Runnable() {
266			public void run(){
267			int added = 0;
268			try {
269			q.put(new Object());
270			++added;
271			q.put(new Object());
272			++added;
273			q.put(new Object());
274			++added;
275			q.put(new Object());
276			++added;
277	dl	1.3	threadFail("Should block");
278	dl	1.1	} catch (InterruptedException e){
279	dl	1.3	threadAssertTrue(added >= 2);
280	dl	1.1	}
281			}
282			});
283			try {
284			t.start();
285			Thread.sleep(SHORT_DELAY_MS);
286			q.take();
287			t.interrupt();
288			t.join();
289			} catch (Exception e){
290			fail("Unexpected exception");
291			}
292			}
293
294			public void testTimedOffer() {
295			final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
296			Thread t = new Thread(new Runnable() {
297			public void run(){
298			try {
299			q.put(new Object());
300			q.put(new Object());
301	dl	1.3	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
302	dl	1.1	q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
303	dl	1.3	threadFail("Should block");
304	dl	1.1	} catch (InterruptedException success){}
305			}
306			});
307
308			try {
309			t.start();
310			Thread.sleep(SHORT_DELAY_MS);
311			t.interrupt();
312			t.join();
313			} catch (Exception e){
314			fail("Unexpected exception");
315			}
316			}
317
318			public void testTake(){
319			try {
320	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
321			for (int i = 0; i < SIZE; ++i) {
322	dl	1.1	assertEquals(i, ((Integer)q.take()).intValue());
323			}
324			} catch (InterruptedException e){
325			fail("Unexpected exception");
326			}
327			}
328
329			public void testTakeFromEmpty() {
330			final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
331			Thread t = new Thread(new Runnable() {
332			public void run(){
333			try {
334			q.take();
335	dl	1.3	threadFail("Should block");
336	dl	1.1	} catch (InterruptedException success){ }
337			}
338			});
339			try {
340			t.start();
341			Thread.sleep(SHORT_DELAY_MS);
342			t.interrupt();
343			t.join();
344			} catch (Exception e){
345			fail("Unexpected exception");
346			}
347			}
348
349			public void testBlockingTake(){
350			Thread t = new Thread(new Runnable() {
351			public void run() {
352			try {
353	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
354			for (int i = 0; i < SIZE; ++i) {
355			threadAssertEquals(i, ((Integer)q.take()).intValue());
356	dl	1.1	}
357			q.take();
358	dl	1.3	threadFail("take should block");
359	dl	1.1	} catch (InterruptedException success){
360			}
361			}});
362			try {
363	dl	1.3	t.start();
364			Thread.sleep(SHORT_DELAY_MS);
365			t.interrupt();
366			t.join();
367	dl	1.1	}
368			catch (InterruptedException ie) {
369			fail("Unexpected exception");
370			}
371			}
372
373
374			public void testPoll(){
375	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
376			for (int i = 0; i < SIZE; ++i) {
377	dl	1.1	assertEquals(i, ((Integer)q.poll()).intValue());
378			}
379			assertNull(q.poll());
380			}
381
382			public void testTimedPoll0() {
383			try {
384	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
385			for (int i = 0; i < SIZE; ++i) {
386	dl	1.1	assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());
387			}
388			assertNull(q.poll(0, TimeUnit.MILLISECONDS));
389			} catch (InterruptedException e){
390			fail("Unexpected exception");
391			}
392			}
393
394			public void testTimedPoll() {
395			try {
396	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
397			for (int i = 0; i < SIZE; ++i) {
398	dl	1.1	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
399			}
400			assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
401			} catch (InterruptedException e){
402			fail("Unexpected exception");
403			}
404			}
405
406			public void testInterruptedTimedPoll(){
407			Thread t = new Thread(new Runnable() {
408			public void run() {
409			try {
410	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
411			for (int i = 0; i < SIZE; ++i) {
412			threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
413	dl	1.1	}
414	dl	1.3	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
415	dl	1.1	} catch (InterruptedException success){
416			}
417			}});
418			try {
419	dl	1.3	t.start();
420			Thread.sleep(SHORT_DELAY_MS);
421			t.interrupt();
422			t.join();
423	dl	1.1	}
424			catch (InterruptedException ie) {
425			fail("Unexpected exception");
426			}
427			}
428
429			public void testTimedPollWithOffer(){
430			final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
431			Thread t = new Thread(new Runnable() {
432			public void run(){
433			try {
434	dl	1.3	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
435	dl	1.1	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
436			q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
437	dl	1.3	threadFail("Should block");
438	dl	1.1	} catch (InterruptedException success) { }
439			}
440			});
441			try {
442			t.start();
443	dl	1.3	Thread.sleep(SMALL_DELAY_MS);
444			assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
445	dl	1.1	t.interrupt();
446			t.join();
447			} catch (Exception e){
448			fail("Unexpected exception");
449			}
450			}
451
452
453			public void testPeek(){
454	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
455			for (int i = 0; i < SIZE; ++i) {
456	dl	1.1	assertEquals(i, ((Integer)q.peek()).intValue());
457			q.poll();
458			assertTrue(q.peek() == null \|\|
459			i != ((Integer)q.peek()).intValue());
460			}
461			assertNull(q.peek());
462			}
463
464			public void testElement(){
465	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
466			for (int i = 0; i < SIZE; ++i) {
467	dl	1.1	assertEquals(i, ((Integer)q.element()).intValue());
468			q.poll();
469			}
470			try {
471			q.element();
472			fail("no such element");
473			}
474			catch (NoSuchElementException success) {}
475			}
476
477			public void testRemove(){
478	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
479			for (int i = 0; i < SIZE; ++i) {
480	dl	1.1	assertEquals(i, ((Integer)q.remove()).intValue());
481			}
482			try {
483			q.remove();
484			fail("remove should throw");
485			} catch (NoSuchElementException success){
486			}
487			}
488
489			public void testRemoveElement(){
490	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
491			for (int i = 1; i < SIZE; i+=2) {
492	dl	1.1	assertTrue(q.remove(new Integer(i)));
493			}
494	dl	1.3	for (int i = 0; i < SIZE; i+=2) {
495	dl	1.1	assertTrue(q.remove(new Integer(i)));
496			assertFalse(q.remove(new Integer(i+1)));
497			}
498	dl	1.2	assertTrue(q.isEmpty());
499	dl	1.1	}
500
501			public void testContains(){
502	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
503			for (int i = 0; i < SIZE; ++i) {
504	dl	1.1	assertTrue(q.contains(new Integer(i)));
505			q.poll();
506			assertFalse(q.contains(new Integer(i)));
507			}
508			}
509
510			public void testClear(){
511	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
512	dl	1.1	q.clear();
513			assertTrue(q.isEmpty());
514			assertEquals(0, q.size());
515	dl	1.3	assertEquals(SIZE, q.remainingCapacity());
516			q.add(one);
517	dl	1.1	assertFalse(q.isEmpty());
518			q.clear();
519			assertTrue(q.isEmpty());
520			}
521
522			public void testContainsAll(){
523	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
524			ArrayBlockingQueue p = new ArrayBlockingQueue(SIZE);
525			for (int i = 0; i < SIZE; ++i) {
526	dl	1.1	assertTrue(q.containsAll(p));
527			assertFalse(p.containsAll(q));
528			p.add(new Integer(i));
529			}
530			assertTrue(p.containsAll(q));
531			}
532
533			public void testRetainAll(){
534	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
535			ArrayBlockingQueue p = populatedQueue(SIZE);
536			for (int i = 0; i < SIZE; ++i) {
537	dl	1.1	boolean changed = q.retainAll(p);
538			if (i == 0)
539			assertFalse(changed);
540			else
541			assertTrue(changed);
542
543			assertTrue(q.containsAll(p));
544	dl	1.3	assertEquals(SIZE-i, q.size());
545	dl	1.1	p.remove();
546			}
547			}
548
549			public void testRemoveAll(){
550	dl	1.3	for (int i = 1; i < SIZE; ++i) {
551			ArrayBlockingQueue q = populatedQueue(SIZE);
552			ArrayBlockingQueue p = populatedQueue(i);
553	dl	1.1	assertTrue(q.removeAll(p));
554	dl	1.3	assertEquals(SIZE-i, q.size());
555	dl	1.1	for (int j = 0; j < i; ++j) {
556			Integer I = (Integer)(p.remove());
557			assertFalse(q.contains(I));
558			}
559			}
560			}
561
562
563			public void testToArray(){
564	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
565	dl	1.1	Object[] o = q.toArray();
566			try {
567			for(int i = 0; i < o.length; i++)
568			assertEquals(o[i], q.take());
569			} catch (InterruptedException e){
570			fail("Unexpected exception");
571			}
572			}
573
574			public void testToArray2(){
575	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
576			Integer[] ints = new Integer[SIZE];
577	dl	1.1	ints = (Integer[])q.toArray(ints);
578			try {
579			for(int i = 0; i < ints.length; i++)
580			assertEquals(ints[i], q.take());
581			} catch (InterruptedException e){
582			fail("Unexpected exception");
583			}
584			}
585
586			public void testIterator(){
587	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
588	dl	1.1	Iterator it = q.iterator();
589			try {
590			while(it.hasNext()){
591			assertEquals(it.next(), q.take());
592			}
593			} catch (InterruptedException e){
594			fail("Unexpected exception");
595			}
596			}
597
598			public void testIteratorOrdering() {
599
600			final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
601
602	dl	1.3	q.add(one);
603			q.add(two);
604			q.add(three);
605	dl	1.1
606			assertEquals("queue should be full", 0, q.remainingCapacity());
607
608			int k = 0;
609			for (Iterator it = q.iterator(); it.hasNext();) {
610			int i = ((Integer)(it.next())).intValue();
611			assertEquals("items should come out in order", ++k, i);
612			}
613
614			assertEquals("should go through 3 elements", 3, k);
615			}
616
617			public void testWeaklyConsistentIteration () {
618
619			final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
620
621	dl	1.3	q.add(one);
622			q.add(two);
623			q.add(three);
624	dl	1.1
625			try {
626			for (Iterator it = q.iterator(); it.hasNext();) {
627			q.remove();
628			it.next();
629			}
630			}
631			catch (ConcurrentModificationException e) {
632			fail("weakly consistent iterator; should not get CME");
633			}
634
635			assertEquals("queue should be empty again", 0, q.size());
636			}
637
638
639			public void testToString(){
640	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
641	dl	1.1	String s = q.toString();
642	dl	1.3	for (int i = 0; i < SIZE; ++i) {
643	dl	1.1	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
644			}
645			}
646
647
648			public void testOfferInExecutor() {
649
650			final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
651
652	dl	1.3	q.add(one);
653			q.add(two);
654	dl	1.1
655			ExecutorService executor = Executors.newFixedThreadPool(2);
656
657			executor.execute(new Runnable() {
658			public void run() {
659	dl	1.3	threadAssertFalse(q.offer(three));
660	dl	1.1	try {
661	dl	1.3	threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
662			threadAssertEquals(0, q.remainingCapacity());
663	dl	1.1	}
664			catch (InterruptedException e) {
665	dl	1.3	threadFail("should not be interrupted");
666	dl	1.1	}
667			}
668			});
669
670			executor.execute(new Runnable() {
671			public void run() {
672			try {
673	dl	1.3	Thread.sleep(SMALL_DELAY_MS);
674			threadAssertEquals(one, q.take());
675	dl	1.1	}
676			catch (InterruptedException e) {
677	dl	1.3	threadFail("should not be interrupted");
678	dl	1.1	}
679			}
680			});
681
682	dl	1.3	joinPool(executor);
683	dl	1.1
684			}
685
686			public void testPollInExecutor() {
687
688			final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
689
690			ExecutorService executor = Executors.newFixedThreadPool(2);
691
692			executor.execute(new Runnable() {
693			public void run() {
694	dl	1.3	threadAssertNull(q.poll());
695	dl	1.1	try {
696	dl	1.3	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
697			threadAssertTrue(q.isEmpty());
698	dl	1.1	}
699			catch (InterruptedException e) {
700	dl	1.3	threadFail("should not be interrupted");
701	dl	1.1	}
702			}
703			});
704
705			executor.execute(new Runnable() {
706			public void run() {
707			try {
708	dl	1.3	Thread.sleep(SMALL_DELAY_MS);
709			q.put(one);
710	dl	1.1	}
711			catch (InterruptedException e) {
712	dl	1.3	threadFail("should not be interrupted");
713	dl	1.1	}
714			}
715			});
716
717	dl	1.3	joinPool(executor);
718	dl	1.1
719			}
720	dl	1.2
721			public void testSerialization() {
722	dl	1.3	ArrayBlockingQueue q = populatedQueue(SIZE);
723	dl	1.2
724			try {
725			ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
726			ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
727			out.writeObject(q);
728			out.close();
729
730			ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
731			ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
732			ArrayBlockingQueue r = (ArrayBlockingQueue)in.readObject();
733			assertEquals(q.size(), r.size());
734			while (!q.isEmpty())
735			assertEquals(q.remove(), r.remove());
736			} catch(Exception e){
737			fail("unexpected exception");
738			}
739			}
740
741	dl	1.1
742			}