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.*;
import java.io.*;

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

    }

    public void testSerialization() {
        LinkedBlockingQueue 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));
            LinkedBlockingQueue r = (LinkedBlockingQueue)in.readObject();
            assertEquals(q.size(), r.size());
            while (!q.isEmpty()) 
                assertEquals(q.remove(), r.remove());
        } catch(Exception e){
            e.printStackTrace();
            fail("unexpected exception");
        }
    }

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