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 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)));
        }
        assertTrue(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();

    }

    public void testSerialization() {
        ArrayBlockingQueue q = fullQueue(N);

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