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 JSR166TestCase {

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

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

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

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

    public void testOfferNull(){
        try {
            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(zero));
        assertFalse(q.offer(one));
    }

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

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

     public void testPutNull() {
        try {
            LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
            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(SIZE);
             for (int i = 0; i < SIZE; ++i) {
                 Integer I = new Integer(i);
                 q.put(I);
                 assertTrue(q.contains(I));
             }
             assertEquals(0, q.remainingCapacity());
         }
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
    }

    public void testBlockingPut(){
        Thread t = new Thread(new Runnable() {
                public void run() {
                    int added = 0;
                    try {
                        LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
                        for (int i = 0; i < SIZE; ++i) {
                            q.put(new Integer(i));
                            ++added;
                        }
                        q.put(new Integer(SIZE));
                        threadFail("put should block");
                    } catch (InterruptedException ie){
                        threadAssertEquals(added, SIZE);
                    }   
                }});
        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;
                        threadFail("Should block");
                    } catch (InterruptedException e){
                        threadAssertTrue(added >= 2);
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            q.take();
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }

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

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

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

    public void testBlockingTake(){
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        LinkedBlockingQueue q = populatedQueue(SIZE);
                        for (int i = 0; i < SIZE; ++i) {
                            assertEquals(i, ((Integer)q.take()).intValue());
                        }
                        q.take();
                        threadFail("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 = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.poll()).intValue());
        }
        assertNull(q.poll());
    }

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

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

    public void testInterruptedTimedPoll(){
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        LinkedBlockingQueue q = populatedQueue(SIZE);
                        for (int i = 0; i < SIZE; ++i) {
                            threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
                        }
                        threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                    } catch (InterruptedException success){
                    }   
                }});
        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 {
                        threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadFail("Should block");
                    } catch (InterruptedException success) { }                
                }
            });
        try {
            t.start();
            Thread.sleep(SMALL_DELAY_MS);
            assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }  


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

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

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

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

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

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

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

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

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


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

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

    public void testIteratorOrdering() {

        final LinkedBlockingQueue q = new LinkedBlockingQueue(3);

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

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

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

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

    public void testWeaklyConsistentIteration () {

        final LinkedBlockingQueue q = new LinkedBlockingQueue(3);

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

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

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


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


    public void testOfferInExecutor() {

        final LinkedBlockingQueue q = new LinkedBlockingQueue(2);

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

        ExecutorService executor = Executors.newFixedThreadPool(2);

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

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

    }

    public void testPollInExecutor() {

        final LinkedBlockingQueue q = new LinkedBlockingQueue(2);

        ExecutorService executor = Executors.newFixedThreadPool(2);

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

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

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

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

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