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.*;

public class ArrayBlockingQueueTest extends TestCase {

    private static int N = 10;
    private static long SHORT_DELAY_MS = 100; 
    private static long MEDIUM_DELAY_MS = 1000;
    private static long LONG_DELAY_MS = 10000; 

    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 fullQueue(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(N, new ArrayBlockingQueue(N).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[N];
            ArrayBlockingQueue q = new ArrayBlockingQueue(N, false, Arrays.asList(ints));
            fail("Cannot make with null elements");
        }
        catch (NullPointerException success) {}
    }

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

    public void testConstructor6(){
        try {
            Integer[] ints = new Integer[N];
            for (int i = 0; i < N; ++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[N];
            for (int i = 0; i < N; ++i)
                ints[i] = new Integer(i);
            ArrayBlockingQueue q = new ArrayBlockingQueue(N, true, Arrays.asList(ints));
            for (int i = 0; i < N; ++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(new Integer(1));
        assertFalse(q.isEmpty());
        q.add(new Integer(2));
        assertFalse(q.isEmpty());
        assertEquals("queue should be full", 0, q.remainingCapacity());
        assertFalse("offer should be rejected", q.offer(new Integer(3)));
    }

    public void testRemainingCapacity(){
        ArrayBlockingQueue q = fullQueue(N);
        for (int i = 0; i < N; ++i) {
            assertEquals(i, q.remainingCapacity());
            assertEquals(N-i, q.size());
            q.remove();
        }
        for (int i = 0; i < N; ++i) {
            assertEquals(N-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(new Integer(0)));
        assertFalse(q.offer(new Integer(1)));
    }

    public void testAdd(){
        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(N);
            for (int i = 0; i < N; ++i) {
                assertTrue(q.add(new Integer(i)));
            }
            assertEquals(0, q.remainingCapacity());
            q.add(new Integer(N));
        } 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(N);
            Integer[] ints = new Integer[N];
            q.addAll(Arrays.asList(ints));
            fail("Cannot add null elements");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll3(){
        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(N);
            Integer[] ints = new Integer[N];
            for (int i = 0; i < N-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[N];
            for (int i = 0; i < N; ++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[N];
            for (int i = 0; i < N; ++i)
                ints[i] = new Integer(i);
            ArrayBlockingQueue q = new ArrayBlockingQueue(N);
            assertFalse(q.addAll(Arrays.asList(empty)));
            assertTrue(q.addAll(Arrays.asList(ints)));
            for (int i = 0; i < N; ++i)
                assertEquals(ints[i], q.poll());
        }
        finally {}
    }

     public void testPutNull() {
        try {
            ArrayBlockingQueue q = new ArrayBlockingQueue(N);
            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(N);
             for (int i = 0; i < N; ++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(N);
                        for (int i = 0; i < N; ++i) {
                            q.put(new Integer(i));
                            ++added;
                        }
                        q.put(new Integer(N));
                        fail("put should block");
                    } catch (InterruptedException ie){
                        assertEquals(added, N);
                    }   
                }});
        t.start();
        try { 
           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;
                        fail("Should block");
                    } catch (InterruptedException e){
                        assertTrue(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());
                        assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
                        q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        fail("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 = fullQueue(N);
            for (int i = 0; i < N; ++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();
                        fail("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 = fullQueue(N);
                        for (int i = 0; i < N; ++i) {
                            assertEquals(i, ((Integer)q.take()).intValue());
                        }
                        q.take();
                        fail("take should block");
                    } catch (InterruptedException success){
                    }   
                }});
        t.start();
        try { 
           Thread.sleep(SHORT_DELAY_MS); 
           t.interrupt();
           t.join();
        }
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
    }


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

    public void testTimedPoll0() {
        try {
            ArrayBlockingQueue q = fullQueue(N);
            for (int i = 0; i < N; ++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 = fullQueue(N);
            for (int i = 0; i < N; ++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 = fullQueue(N);
                        for (int i = 0; i < N; ++i) {
                            assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
                        }
                        assertNull(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) {
            fail("Unexpected exception");
        }
    }

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


    public void testPeek(){
        ArrayBlockingQueue q = fullQueue(N);
        for (int i = 0; i < N; ++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 = fullQueue(N);
        for (int i = 0; i < N; ++i) {
            assertEquals(i, ((Integer)q.element()).intValue());
            q.poll();
        }
        try {
            q.element();
            fail("no such element");
        }
        catch (NoSuchElementException success) {}
    }

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

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

    public void testClear(){
        ArrayBlockingQueue q = fullQueue(N);
        q.clear();
        assertTrue(q.isEmpty());
        assertEquals(0, q.size());
        assertEquals(N, q.remainingCapacity());
        q.add(new Integer(1));
        assertFalse(q.isEmpty());
        q.clear();
        assertTrue(q.isEmpty());
    }

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

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

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

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


    public void testToArray(){
        ArrayBlockingQueue q = fullQueue(N);
        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 = fullQueue(N);
        Integer[] ints = new Integer[N];
        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 = fullQueue(N);
        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(new Integer(1));
        q.add(new Integer(2));
        q.add(new Integer(3));

        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(new Integer(1));
        q.add(new Integer(2));
        q.add(new Integer(3));

        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 = fullQueue(N);
        String s = q.toString();
        for (int i = 0; i < N; ++i) {
            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
        }
    }        


    public void testOfferInExecutor() {

        final ArrayBlockingQueue q = new ArrayBlockingQueue(2);

        q.add(new Integer(1));
        q.add(new Integer(2));

        ExecutorService executor = Executors.newFixedThreadPool(2);

        executor.execute(new Runnable() {
            public void run() {
                assertFalse("offer should be rejected", q.offer(new Integer(3)));
                try {
                    assertTrue("offer should be accepted", q.offer(new Integer(3), MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));
                    assertEquals(0, q.remainingCapacity());
                }
                catch (InterruptedException e) {
                    fail("should not be interrupted");
                }
            }
        });

        executor.execute(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(MEDIUM_DELAY_MS);
                    assertEquals("first item in queue should be 1", new Integer(1), q.take());
                }
                catch (InterruptedException e) {
                    fail("should not be interrupted");
                }
            }
        });
        
        executor.shutdown();

    }

    public void testPollInExecutor() {

        final ArrayBlockingQueue q = new ArrayBlockingQueue(2);

        ExecutorService executor = Executors.newFixedThreadPool(2);

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

        executor.execute(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(MEDIUM_DELAY_MS);
                    q.put(new Integer(1));
                }
                catch (InterruptedException e) {
                    fail("should not be interrupted");
                }
            }
        });
        
        executor.shutdown();

    }

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