[cvs] / jsr166 / src / test / tck / BlockingQueueTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/BlockingQueueTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2, Thu Oct 28 17:57:26 2010 UTC revision 1.14, Wed Dec 31 20:09:08 2014 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by Doug Lea and Martin Buchholz with assistance from members   * Written by Doug Lea and Martin Buchholz with assistance from members
3   * of JCP JSR-166 Expert Group and released to the public domain, as   * of JCP JSR-166 Expert Group and released to the public domain, as
4   * explained at http://creativecommons.org/licenses/publicdomain   * explained at http://creativecommons.org/publicdomain/zero/1.0/
5   *   *
6   * Other contributors include Andrew Wright, Jeffrey Hayes,   * Other contributors include Andrew Wright, Jeffrey Hayes,
7   * Pat Fisher, Mike Judd.   * Pat Fisher, Mike Judd.
8   */   */
9    
 import junit.framework.*;  
 import java.util.*;  
 import java.util.concurrent.*;  
10  import static java.util.concurrent.TimeUnit.MILLISECONDS;  import static java.util.concurrent.TimeUnit.MILLISECONDS;
11    
12    import java.util.ArrayList;
13    import java.util.Arrays;
14    import java.util.Collection;
15    import java.util.Queue;
16    import java.util.concurrent.BlockingQueue;
17    import java.util.concurrent.CountDownLatch;
18    
19    import junit.framework.Test;
20    import junit.framework.TestSuite;
21    
22  /**  /**
23   * Contains tests generally applicable to BlockingQueue implementations.   * Contains "contract" tests applicable to all BlockingQueue implementations.
24   */   */
25  public abstract class BlockingQueueTest extends JSR166TestCase {  public abstract class BlockingQueueTest extends JSR166TestCase {
26      /*      /*
# Line 33  Line 40 
40          return new TestSuite(this.getClass());          return new TestSuite(this.getClass());
41      }      }
42    
43        //----------------------------------------------------------------
44        // Configuration methods
45        //----------------------------------------------------------------
46    
47      /** Returns an empty instance of the implementation class. */      /** Returns an empty instance of the implementation class. */
48      protected abstract BlockingQueue emptyCollection();      protected abstract BlockingQueue emptyCollection();
49    
50      /**      /**
51       * timed poll before a delayed offer fails; after offer succeeds;       * Returns an element suitable for insertion in the collection.
52         * Override for collections with unusual element types.
53         */
54        protected Object makeElement(int i) {
55            return Integer.valueOf(i);
56        }
57    
58        //----------------------------------------------------------------
59        // Tests
60        //----------------------------------------------------------------
61    
62        /**
63         * offer(null) throws NullPointerException
64         */
65        public void testOfferNull() {
66            final Queue q = emptyCollection();
67            try {
68                q.offer(null);
69                shouldThrow();
70            } catch (NullPointerException success) {}
71        }
72    
73        /**
74         * add(null) throws NullPointerException
75         */
76        public void testAddNull() {
77            final Collection q = emptyCollection();
78            try {
79                q.add(null);
80                shouldThrow();
81            } catch (NullPointerException success) {}
82        }
83    
84        /**
85         * timed offer(null) throws NullPointerException
86         */
87        public void testTimedOfferNull() throws InterruptedException {
88            final BlockingQueue q = emptyCollection();
89            long startTime = System.nanoTime();
90            try {
91                q.offer(null, LONG_DELAY_MS, MILLISECONDS);
92                shouldThrow();
93            } catch (NullPointerException success) {}
94            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
95        }
96    
97        /**
98         * put(null) throws NullPointerException
99         */
100        public void testPutNull() throws InterruptedException {
101            final BlockingQueue q = emptyCollection();
102            try {
103                q.put(null);
104                shouldThrow();
105            } catch (NullPointerException success) {}
106        }
107    
108        /**
109         * put(null) throws NullPointerException
110         */
111        public void testAddAllNull() throws InterruptedException {
112            final Collection q = emptyCollection();
113            try {
114                q.addAll(null);
115                shouldThrow();
116            } catch (NullPointerException success) {}
117        }
118    
119        /**
120         * addAll of a collection with null elements throws NullPointerException
121         */
122        public void testAddAllNullElements() {
123            final Collection q = emptyCollection();
124            final Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
125            try {
126                q.addAll(elements);
127                shouldThrow();
128            } catch (NullPointerException success) {}
129        }
130    
131        /**
132         * toArray(null) throws NullPointerException
133         */
134        public void testToArray_NullArray() {
135            final Collection q = emptyCollection();
136            try {
137                q.toArray(null);
138                shouldThrow();
139            } catch (NullPointerException success) {}
140        }
141    
142        /**
143         * drainTo(null) throws NullPointerException
144         */
145        public void testDrainToNull() {
146            final BlockingQueue q = emptyCollection();
147            try {
148                q.drainTo(null);
149                shouldThrow();
150            } catch (NullPointerException success) {}
151        }
152    
153        /**
154         * drainTo(this) throws IllegalArgumentException
155         */
156        public void testDrainToSelf() {
157            final BlockingQueue q = emptyCollection();
158            try {
159                q.drainTo(q);
160                shouldThrow();
161            } catch (IllegalArgumentException success) {}
162        }
163    
164        /**
165         * drainTo(null, n) throws NullPointerException
166         */
167        public void testDrainToNullN() {
168            final BlockingQueue q = emptyCollection();
169            try {
170                q.drainTo(null, 0);
171                shouldThrow();
172            } catch (NullPointerException success) {}
173        }
174    
175        /**
176         * drainTo(this, n) throws IllegalArgumentException
177         */
178        public void testDrainToSelfN() {
179            final BlockingQueue q = emptyCollection();
180            try {
181                q.drainTo(q, 0);
182                shouldThrow();
183            } catch (IllegalArgumentException success) {}
184        }
185    
186        /**
187         * drainTo(c, n) returns 0 and does nothing when n <= 0
188         */
189        public void testDrainToNonPositiveMaxElements() {
190            final BlockingQueue q = emptyCollection();
191            final int[] ns = { 0, -1, -42, Integer.MIN_VALUE };
192            for (int n : ns)
193                assertEquals(0, q.drainTo(new ArrayList(), n));
194            if (q.remainingCapacity() > 0) {
195                // Not SynchronousQueue, that is
196                Object one = makeElement(1);
197                q.add(one);
198                ArrayList c = new ArrayList();
199                for (int n : ns)
200                    assertEquals(0, q.drainTo(new ArrayList(), n));
201                assertEquals(1, q.size());
202                assertSame(one, q.poll());
203                assertTrue(c.isEmpty());
204            }
205        }
206    
207        /**
208         * timed poll before a delayed offer times out; after offer succeeds;
209       * on interruption throws       * on interruption throws
210       */       */
211      public void testTimedPollWithOffer() throws InterruptedException {      public void testTimedPollWithOffer() throws InterruptedException {
212          final BlockingQueue q = emptyCollection();          final BlockingQueue q = emptyCollection();
213          final CheckedBarrier barrier = new CheckedBarrier(2);          final CheckedBarrier barrier = new CheckedBarrier(2);
214            final Object zero = makeElement(0);
215          Thread t = newStartedThread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
216              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
217                  assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));                  long startTime = System.nanoTime();
218                    assertNull(q.poll(timeoutMillis(), MILLISECONDS));
219                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
220    
221                  barrier.await();                  barrier.await();
222                  assertSame(zero, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));  
223                    assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
224    
225                  Thread.currentThread().interrupt();                  Thread.currentThread().interrupt();
226                  try {                  try {
227                      q.poll(SHORT_DELAY_MS, MILLISECONDS);                      q.poll(LONG_DELAY_MS, MILLISECONDS);
228                      shouldThrow();                      shouldThrow();
229                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
230                    assertFalse(Thread.interrupted());
231    
232                  barrier.await();                  barrier.await();
233                  try {                  try {
234                      q.poll(MEDIUM_DELAY_MS, MILLISECONDS);                      q.poll(LONG_DELAY_MS, MILLISECONDS);
235                      shouldThrow();                      shouldThrow();
236                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
237                    assertFalse(Thread.interrupted());
238              }});              }});
239    
240          barrier.await();          barrier.await();
241          assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));          long startTime = System.nanoTime();
242            assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
243            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
244    
245          barrier.await();          barrier.await();
246          sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
247          t.interrupt();          t.interrupt();
248          awaitTermination(t, MEDIUM_DELAY_MS);          awaitTermination(t);
249      }      }
250    
251      /**      /**
252       * take blocks interruptibly when empty       * take() blocks interruptibly when empty
253       */       */
254      public void testTakeFromEmptyBlocksInterruptibly()      public void testTakeFromEmptyBlocksInterruptibly() {
             throws InterruptedException {  
255          final BlockingQueue q = emptyCollection();          final BlockingQueue q = emptyCollection();
256          final CountDownLatch threadStarted = new CountDownLatch(1);          final CountDownLatch threadStarted = new CountDownLatch(1);
257          Thread t = newStartedThread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
258              public void realRun() {              public void realRun() {
                 long t0 = System.nanoTime();  
259                  threadStarted.countDown();                  threadStarted.countDown();
260                  try {                  try {
261                      q.take();                      q.take();
262                      shouldThrow();                      shouldThrow();
263                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
264                  assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);                  assertFalse(Thread.interrupted());
265              }});              }});
266          threadStarted.await();  
267          Thread.sleep(SHORT_DELAY_MS);          await(threadStarted);
268          assertTrue(t.isAlive());          assertThreadStaysAlive(t);
269          t.interrupt();          t.interrupt();
270          awaitTermination(t, MEDIUM_DELAY_MS);          awaitTermination(t);
271          assertFalse(t.isAlive());      }
272    
273        /**
274         * take() throws InterruptedException immediately if interrupted
275         * before waiting
276         */
277        public void testTakeFromEmptyAfterInterrupt() {
278            final BlockingQueue q = emptyCollection();
279            Thread t = newStartedThread(new CheckedRunnable() {
280                public void realRun() {
281                    Thread.currentThread().interrupt();
282                    try {
283                        q.take();
284                        shouldThrow();
285                    } catch (InterruptedException success) {}
286                    assertFalse(Thread.interrupted());
287                }});
288    
289            awaitTermination(t);
290        }
291    
292        /**
293         * timed poll() blocks interruptibly when empty
294         */
295        public void testTimedPollFromEmptyBlocksInterruptibly() {
296            final BlockingQueue q = emptyCollection();
297            final CountDownLatch threadStarted = new CountDownLatch(1);
298            Thread t = newStartedThread(new CheckedRunnable() {
299                public void realRun() {
300                    threadStarted.countDown();
301                    try {
302                        q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
303                        shouldThrow();
304                    } catch (InterruptedException success) {}
305                    assertFalse(Thread.interrupted());
306                }});
307    
308            await(threadStarted);
309            assertThreadStaysAlive(t);
310            t.interrupt();
311            awaitTermination(t);
312        }
313    
314        /**
315         * timed poll() throws InterruptedException immediately if
316         * interrupted before waiting
317         */
318        public void testTimedPollFromEmptyAfterInterrupt() {
319            final BlockingQueue q = emptyCollection();
320            Thread t = newStartedThread(new CheckedRunnable() {
321                public void realRun() {
322                    Thread.currentThread().interrupt();
323                    try {
324                        q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
325                        shouldThrow();
326                    } catch (InterruptedException success) {}
327                    assertFalse(Thread.interrupted());
328                }});
329    
330            awaitTermination(t);
331        }
332    
333        /**
334         * remove(x) removes x and returns true if present
335         * TODO: move to superclass CollectionTest.java
336         */
337        public void testRemoveElement() {
338            final BlockingQueue q = emptyCollection();
339            final int size = Math.min(q.remainingCapacity(), SIZE);
340            final Object[] elts = new Object[size];
341            assertFalse(q.contains(makeElement(99)));
342            assertFalse(q.remove(makeElement(99)));
343            checkEmpty(q);
344            for (int i = 0; i < size; i++)
345                q.add(elts[i] = makeElement(i));
346            for (int i = 1; i < size; i += 2) {
347                for (int pass = 0; pass < 2; pass++) {
348                    assertEquals((pass == 0), q.contains(elts[i]));
349                    assertEquals((pass == 0), q.remove(elts[i]));
350                    assertFalse(q.contains(elts[i]));
351                    assertTrue(q.contains(elts[i-1]));
352                    if (i < size - 1)
353                        assertTrue(q.contains(elts[i+1]));
354                }
355            }
356            if (size > 0)
357                assertTrue(q.contains(elts[0]));
358            for (int i = size-2; i >= 0; i -= 2) {
359                assertTrue(q.contains(elts[i]));
360                assertFalse(q.contains(elts[i+1]));
361                assertTrue(q.remove(elts[i]));
362                assertFalse(q.contains(elts[i]));
363                assertFalse(q.remove(elts[i+1]));
364                assertFalse(q.contains(elts[i+1]));
365            }
366            checkEmpty(q);
367      }      }
368    
369      /** For debugging. */      /** For debugging. */

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.14

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8