test/tck/LinkedBlockingQueueTest.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 LinkedBlockingQueueTest 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(LinkedBlockingQueueTest.class);
    }

    /**
     * Create a queue of given size containing consecutive
     * Integers 0 ... n.
     */
    private LinkedBlockingQueue fullQueue(int n) {
        LinkedBlockingQueue q = new LinkedBlockingQueue(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 LinkedBlockingQueue(N).remainingCapacity());
    }

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

    public void testConstructor3(){

        try {
            LinkedBlockingQueue q = new LinkedBlockingQueue(null);
            fail("Cannot make from null collection");
        }
        catch (NullPointerException success) {}
    }

    public void testConstructor4(){
        try {
            Integer[] ints = new Integer[N];
            LinkedBlockingQueue q = new LinkedBlockingQueue(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);
            LinkedBlockingQueue q = new LinkedBlockingQueue(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);
            LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints));
            for (int i = 0; i < N; ++i)
                assertEquals(ints[i], q.poll());
        }
        finally {}
    }

    public void testEmptyFull() {
        LinkedBlockingQueue q = new LinkedBlockingQueue(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(){
        LinkedBlockingQueue 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 {
            LinkedBlockingQueue q = new LinkedBlockingQueue(1);
            q.offer(null);
            fail("should throw NPE");
        } catch (NullPointerException success) { }   
    }

    public void testOffer(){
        LinkedBlockingQueue q = new LinkedBlockingQueue(1);
        assertTrue(q.offer(new Integer(0)));
        assertFalse(q.offer(new Integer(1)));
    }

    public void testAdd(){
        try {
            LinkedBlockingQueue q = new LinkedBlockingQueue(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 {
            LinkedBlockingQueue q = new LinkedBlockingQueue(1);
            q.addAll(null);
            fail("Cannot add null collection");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll2(){
        try {
            LinkedBlockingQueue q = new LinkedBlockingQueue(N);
            Integer[] ints = new Integer[N];
            q.addAll(Arrays.asList(ints));
            fail("Cannot add null elements");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll3(){
        try {
            LinkedBlockingQueue q = new LinkedBlockingQueue(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 {
            LinkedBlockingQueue q = new LinkedBlockingQueue(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);
            LinkedBlockingQueue q = new LinkedBlockingQueue(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 {
            LinkedBlockingQueue q = new LinkedBlockingQueue(N);
            q.put(null);
            fail("put should throw NPE");
        } 
        catch (NullPointerException success){
        }   
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
     }

     public void testPut() {
         try {
             LinkedBlockingQueue q = new LinkedBlockingQueue(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 {
                        LinkedBlockingQueue q = new LinkedBlockingQueue(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 LinkedBlockingQueue q = new LinkedBlockingQueue(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 LinkedBlockingQueue q = new LinkedBlockingQueue(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 {
            LinkedBlockingQueue 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 LinkedBlockingQueue q = new LinkedBlockingQueue(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 {
                        LinkedBlockingQueue 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(){
        LinkedBlockingQueue q = fullQueue(N);
        for (int i = 0; i < N; ++i) {
            assertEquals(i, ((Integer)q.poll()).intValue());
        }
        assertNull(q.poll());
    }

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