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

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

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

revision 1.1, Sun Aug 31 19:24:52 2003 UTC revision 1.6, Sun Oct 5 23:00:39 2003 UTC
# Line 5  Line 5 
5   * Jeffrey Hayes, Pat Fischer, Mike Judd.   * Jeffrey Hayes, Pat Fischer, Mike Judd.
6   */   */
7    
8    
9  import junit.framework.*;  import junit.framework.*;
10  import java.util.*;  import java.util.*;
11  import java.util.concurrent.*;  import java.util.concurrent.*;
12    import java.io.*;
13    
14  public class ArrayBlockingQueueTest extends TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
   
     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;  
   
15      public static void main(String[] args) {      public static void main(String[] args) {
16          junit.textui.TestRunner.run (suite());          junit.textui.TestRunner.run (suite());
17      }      }
   
18      public static Test suite() {      public static Test suite() {
19          return new TestSuite(ArrayBlockingQueueTest.class);          return new TestSuite(ArrayBlockingQueueTest.class);
20      }      }
# Line 28  Line 23 
23       * Create a queue of given size containing consecutive       * Create a queue of given size containing consecutive
24       * Integers 0 ... n.       * Integers 0 ... n.
25       */       */
26      private ArrayBlockingQueue fullQueue(int n) {      private ArrayBlockingQueue populatedQueue(int n) {
27          ArrayBlockingQueue q = new ArrayBlockingQueue(n);          ArrayBlockingQueue q = new ArrayBlockingQueue(n);
28          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
29          for(int i = 0; i < n; i++)          for(int i = 0; i < n; i++)
# Line 39  Line 34 
34          return q;          return q;
35      }      }
36    
37        /**
38         * A new queue has the indicated capacity
39         */
40      public void testConstructor1(){      public void testConstructor1(){
41          assertEquals(N, new ArrayBlockingQueue(N).remainingCapacity());          assertEquals(SIZE, new ArrayBlockingQueue(SIZE).remainingCapacity());
42      }      }
43    
44        /**
45         * Constructor throws IAE if  capacity argument nonpositive
46         */
47      public void testConstructor2(){      public void testConstructor2(){
48          try {          try {
49              ArrayBlockingQueue q = new ArrayBlockingQueue(0);              ArrayBlockingQueue q = new ArrayBlockingQueue(0);
50              fail("Cannot make zero-sized");              shouldThrow();
51          }          }
52          catch (IllegalArgumentException success) {}          catch (IllegalArgumentException success) {}
53      }      }
54    
55        /**
56         * Initializing from null Collection throws NPE
57         */
58      public void testConstructor3(){      public void testConstructor3(){
   
59          try {          try {
60              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);
61              fail("Cannot make from null collection");              shouldThrow();
62          }          }
63          catch (NullPointerException success) {}          catch (NullPointerException success) {}
64      }      }
65    
66        /**
67         * Initializing from Collection of null elements throws NPE
68         */
69      public void testConstructor4(){      public void testConstructor4(){
70          try {          try {
71              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
72              ArrayBlockingQueue q = new ArrayBlockingQueue(N, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
73              fail("Cannot make with null elements");              shouldThrow();
74          }          }
75          catch (NullPointerException success) {}          catch (NullPointerException success) {}
76      }      }
77    
78        /**
79         * Initializing from Collection with some null elements throws NPE
80         */
81      public void testConstructor5(){      public void testConstructor5(){
82          try {          try {
83              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
84              for (int i = 0; i < N-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
85                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
86              ArrayBlockingQueue q = new ArrayBlockingQueue(N, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
87              fail("Cannot make with null elements");              shouldThrow();
88          }          }
89          catch (NullPointerException success) {}          catch (NullPointerException success) {}
90      }      }
91    
92        /**
93         * Initializing from too large collection throws IAE
94         */
95      public void testConstructor6(){      public void testConstructor6(){
96          try {          try {
97              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
98              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
99                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
100              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));
101              fail("Cannot make with insufficient capacity");              shouldThrow();
102          }          }
103          catch (IllegalArgumentException success) {}          catch (IllegalArgumentException success) {}
104      }      }
105    
106        /**
107         * Queue contains all elements of collection used to initialize
108         */
109      public void testConstructor7(){      public void testConstructor7(){
110          try {          try {
111              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
112              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
113                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
114              ArrayBlockingQueue q = new ArrayBlockingQueue(N, true, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));
115              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
116                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
117          }          }
118          finally {}          finally {}
119      }      }
120    
121        /**
122         * Queue transitions from empty to full when elements added
123         */
124      public void testEmptyFull() {      public void testEmptyFull() {
125          ArrayBlockingQueue q = new ArrayBlockingQueue(2);          ArrayBlockingQueue q = new ArrayBlockingQueue(2);
126          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
127          assertEquals("should have room for 2", 2, q.remainingCapacity());          assertEquals(2, q.remainingCapacity());
128          q.add(new Integer(1));          q.add(one);
129          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
130          q.add(new Integer(2));          q.add(two);
131          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
132          assertEquals("queue should be full", 0, q.remainingCapacity());          assertEquals(0, q.remainingCapacity());
133          assertFalse("offer should be rejected", q.offer(new Integer(3)));          assertFalse(q.offer(three));
134      }      }
135    
136        /**
137         * remainingCapacity decreases on add, increases on remove
138         */
139      public void testRemainingCapacity(){      public void testRemainingCapacity(){
140          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
141          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
142              assertEquals(i, q.remainingCapacity());              assertEquals(i, q.remainingCapacity());
143              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
144              q.remove();              q.remove();
145          }          }
146          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
147              assertEquals(N-i, q.remainingCapacity());              assertEquals(SIZE-i, q.remainingCapacity());
148              assertEquals(i, q.size());              assertEquals(i, q.size());
149              q.add(new Integer(i));              q.add(new Integer(i));
150          }          }
151      }      }
152    
153        /**
154         *  offer(null) throws NPE
155         */
156      public void testOfferNull(){      public void testOfferNull(){
157          try {          try {
158              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
159              q.offer(null);              q.offer(null);
160              fail("should throw NPE");              shouldThrow();
161            } catch (NullPointerException success) { }
162        }
163    
164        /**
165         *  add(null) throws NPE
166         */
167        public void testAddNull() {
168            try {
169                ArrayBlockingQueue q = new ArrayBlockingQueue(1);
170                q.add(null);
171                shouldThrow();
172          } catch (NullPointerException success) { }          } catch (NullPointerException success) { }
173      }      }
174    
175        /**
176         * Offer succeeds if not full; fails if full
177         */
178      public void testOffer(){      public void testOffer(){
179          ArrayBlockingQueue q = new ArrayBlockingQueue(1);          ArrayBlockingQueue q = new ArrayBlockingQueue(1);
180          assertTrue(q.offer(new Integer(0)));          assertTrue(q.offer(zero));
181          assertFalse(q.offer(new Integer(1)));          assertFalse(q.offer(one));
182      }      }
183    
184        /**
185         * add succeeds if not full; throws ISE if full
186         */
187      public void testAdd(){      public void testAdd(){
188          try {          try {
189              ArrayBlockingQueue q = new ArrayBlockingQueue(N);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
190              for (int i = 0; i < N; ++i) {              for (int i = 0; i < SIZE; ++i) {
191                  assertTrue(q.add(new Integer(i)));                  assertTrue(q.add(new Integer(i)));
192              }              }
193              assertEquals(0, q.remainingCapacity());              assertEquals(0, q.remainingCapacity());
194              q.add(new Integer(N));              q.add(new Integer(SIZE));
195          } catch (IllegalStateException success){          } catch (IllegalStateException success){
196          }          }
197      }      }
198    
199        /**
200         *  addAll(null) throws NPE
201         */
202      public void testAddAll1(){      public void testAddAll1(){
203          try {          try {
204              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
205              q.addAll(null);              q.addAll(null);
206              fail("Cannot add null collection");              shouldThrow();
207          }          }
208          catch (NullPointerException success) {}          catch (NullPointerException success) {}
209      }      }
210    
211        /**
212         * addAll(this) throws IAE
213         */
214        public void testAddAllSelf() {
215            try {
216                ArrayBlockingQueue q = populatedQueue(SIZE);
217                q.addAll(q);
218                shouldThrow();
219            }
220            catch (IllegalArgumentException success) {}
221        }
222    
223    
224        /**
225         *  addAll of a collection with null elements throws NPE
226         */
227      public void testAddAll2(){      public void testAddAll2(){
228          try {          try {
229              ArrayBlockingQueue q = new ArrayBlockingQueue(N);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
230              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
231              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
232              fail("Cannot add null elements");              shouldThrow();
233          }          }
234          catch (NullPointerException success) {}          catch (NullPointerException success) {}
235      }      }
236        /**
237         * addAll of a collection with any null elements throws NPE after
238         * possibly adding some elements
239         */
240      public void testAddAll3(){      public void testAddAll3(){
241          try {          try {
242              ArrayBlockingQueue q = new ArrayBlockingQueue(N);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
243              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
244              for (int i = 0; i < N-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
245                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
246              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
247              fail("Cannot add null elements");              shouldThrow();
248          }          }
249          catch (NullPointerException success) {}          catch (NullPointerException success) {}
250      }      }
251        /**
252         * addAll throws ISE if not enough room
253         */
254      public void testAddAll4(){      public void testAddAll4(){
255          try {          try {
256              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
257              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
258              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
259                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
260              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
261              fail("Cannot add with insufficient capacity");              shouldThrow();
262          }          }
263          catch (IllegalStateException success) {}          catch (IllegalStateException success) {}
264      }      }
265        /**
266         * Queue contains all elements, in traversal order, of successful addAll
267         */
268      public void testAddAll5(){      public void testAddAll5(){
269          try {          try {
270              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
271              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
272              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
273                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
274              ArrayBlockingQueue q = new ArrayBlockingQueue(N);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
275              assertFalse(q.addAll(Arrays.asList(empty)));              assertFalse(q.addAll(Arrays.asList(empty)));
276              assertTrue(q.addAll(Arrays.asList(ints)));              assertTrue(q.addAll(Arrays.asList(ints)));
277              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
278                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
279          }          }
280          finally {}          finally {}
281      }      }
282    
283        /**
284         *  put(null) throws NPE
285         */
286       public void testPutNull() {       public void testPutNull() {
287          try {          try {
288              ArrayBlockingQueue q = new ArrayBlockingQueue(N);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
289              q.put(null);              q.put(null);
290              fail("put should throw NPE");              shouldThrow();
291          }          }
292          catch (NullPointerException success){          catch (NullPointerException success){
293          }          }
294          catch (InterruptedException ie) {          catch (InterruptedException ie) {
295              fail("Unexpected exception");              unexpectedException();
296          }          }
297       }       }
298    
299        /**
300         * all elements successfully put are contained
301         */
302       public void testPut() {       public void testPut() {
303           try {           try {
304               ArrayBlockingQueue q = new ArrayBlockingQueue(N);               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
305               for (int i = 0; i < N; ++i) {               for (int i = 0; i < SIZE; ++i) {
306                   Integer I = new Integer(i);                   Integer I = new Integer(i);
307                   q.put(I);                   q.put(I);
308                   assertTrue(q.contains(I));                   assertTrue(q.contains(I));
# Line 233  Line 310 
310               assertEquals(0, q.remainingCapacity());               assertEquals(0, q.remainingCapacity());
311           }           }
312          catch (InterruptedException ie) {          catch (InterruptedException ie) {
313              fail("Unexpected exception");              unexpectedException();
314          }          }
315      }      }
316    
317        /**
318         * put blocks interruptibly if full
319         */
320      public void testBlockingPut(){      public void testBlockingPut(){
321          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
322                  public void run() {                  public void run() {
323                      int added = 0;                      int added = 0;
324                      try {                      try {
325                          ArrayBlockingQueue q = new ArrayBlockingQueue(N);                          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
326                          for (int i = 0; i < N; ++i) {                          for (int i = 0; i < SIZE; ++i) {
327                              q.put(new Integer(i));                              q.put(new Integer(i));
328                              ++added;                              ++added;
329                          }                          }
330                          q.put(new Integer(N));                          q.put(new Integer(SIZE));
331                          fail("put should block");                          threadShouldThrow();
332                      } catch (InterruptedException ie){                      } catch (InterruptedException ie){
333                          assertEquals(added, N);                          threadAssertEquals(added, SIZE);
334                      }                      }
335                  }});                  }});
         t.start();  
336          try {          try {
337                t.start();
338             Thread.sleep(SHORT_DELAY_MS);             Thread.sleep(SHORT_DELAY_MS);
339             t.interrupt();             t.interrupt();
340             t.join();             t.join();
341          }          }
342          catch (InterruptedException ie) {          catch (InterruptedException ie) {
343              fail("Unexpected exception");              unexpectedException();
344          }          }
345      }      }
346    
347        /**
348         * put blocks waiting for take when full
349         */
350      public void testPutWithTake() {      public void testPutWithTake() {
351          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
352          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 278  Line 361 
361                          ++added;                          ++added;
362                          q.put(new Object());                          q.put(new Object());
363                          ++added;                          ++added;
364                          fail("Should block");                          threadShouldThrow();
365                      } catch (InterruptedException e){                      } catch (InterruptedException e){
366                          assertTrue(added >= 2);                          threadAssertTrue(added >= 2);
367                      }                      }
368                  }                  }
369              });              });
# Line 291  Line 374 
374              t.interrupt();              t.interrupt();
375              t.join();              t.join();
376          } catch (Exception e){          } catch (Exception e){
377              fail("Unexpected exception");              unexpectedException();
378          }          }
379      }      }
380    
381        /**
382         * timed offer times out if full and elements not taken
383         */
384      public void testTimedOffer() {      public void testTimedOffer() {
385          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
386          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 302  Line 388 
388                      try {                      try {
389                          q.put(new Object());                          q.put(new Object());
390                          q.put(new Object());                          q.put(new Object());
391                          assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
392                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
393                          fail("Should block");                          threadShouldThrow();
394                      } catch (InterruptedException success){}                      } catch (InterruptedException success){}
395                  }                  }
396              });              });
# Line 315  Line 401 
401              t.interrupt();              t.interrupt();
402              t.join();              t.join();
403          } catch (Exception e){          } catch (Exception e){
404              fail("Unexpected exception");              unexpectedException();
405          }          }
406      }      }
407    
408        /**
409         * take retrieves elements in FIFO order
410         */
411      public void testTake(){      public void testTake(){
412          try {          try {
413              ArrayBlockingQueue q = fullQueue(N);              ArrayBlockingQueue q = populatedQueue(SIZE);
414              for (int i = 0; i < N; ++i) {              for (int i = 0; i < SIZE; ++i) {
415                  assertEquals(i, ((Integer)q.take()).intValue());                  assertEquals(i, ((Integer)q.take()).intValue());
416              }              }
417          } catch (InterruptedException e){          } catch (InterruptedException e){
418              fail("Unexpected exception");              unexpectedException();
419          }          }
420      }      }
421    
422        /**
423         * take blocks interruptibly when empty
424         */
425      public void testTakeFromEmpty() {      public void testTakeFromEmpty() {
426          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
427          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
428                  public void run(){                  public void run(){
429                      try {                      try {
430                          q.take();                          q.take();
431                          fail("Should block");                          threadShouldThrow();
432                      } catch (InterruptedException success){ }                      } catch (InterruptedException success){ }
433                  }                  }
434              });              });
# Line 346  Line 438 
438              t.interrupt();              t.interrupt();
439              t.join();              t.join();
440          } catch (Exception e){          } catch (Exception e){
441              fail("Unexpected exception");              unexpectedException();
442          }          }
443      }      }
444    
445        /**
446         * Take removes existing elements until empty, then blocks interruptibly
447         */
448      public void testBlockingTake(){      public void testBlockingTake(){
449          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
450                  public void run() {                  public void run() {
451                      try {                      try {
452                          ArrayBlockingQueue q = fullQueue(N);                          ArrayBlockingQueue q = populatedQueue(SIZE);
453                          for (int i = 0; i < N; ++i) {                          for (int i = 0; i < SIZE; ++i) {
454                              assertEquals(i, ((Integer)q.take()).intValue());                              threadAssertEquals(i, ((Integer)q.take()).intValue());
455                          }                          }
456                          q.take();                          q.take();
457                          fail("take should block");                          threadShouldThrow();
458                      } catch (InterruptedException success){                      } catch (InterruptedException success){
459                      }                      }
460                  }});                  }});
         t.start();  
461          try {          try {
462                t.start();
463             Thread.sleep(SHORT_DELAY_MS);             Thread.sleep(SHORT_DELAY_MS);
464             t.interrupt();             t.interrupt();
465             t.join();             t.join();
466          }          }
467          catch (InterruptedException ie) {          catch (InterruptedException ie) {
468              fail("Unexpected exception");              unexpectedException();
469          }          }
470      }      }
471    
472    
473        /**
474         * poll succeeds unless empty
475         */
476      public void testPoll(){      public void testPoll(){
477          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
478          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
479              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, ((Integer)q.poll()).intValue());
480          }          }
481          assertNull(q.poll());          assertNull(q.poll());
482      }      }
483    
484        /**
485         * timed pool with zero timeout succeeds when non-empty, else times out
486         */
487      public void testTimedPoll0() {      public void testTimedPoll0() {
488          try {          try {
489              ArrayBlockingQueue q = fullQueue(N);              ArrayBlockingQueue q = populatedQueue(SIZE);
490              for (int i = 0; i < N; ++i) {              for (int i = 0; i < SIZE; ++i) {
491                  assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());                  assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());
492              }              }
493              assertNull(q.poll(0, TimeUnit.MILLISECONDS));              assertNull(q.poll(0, TimeUnit.MILLISECONDS));
494          } catch (InterruptedException e){          } catch (InterruptedException e){
495              fail("Unexpected exception");              unexpectedException();
496          }          }
497      }      }
498    
499        /**
500         * timed pool with nonzero timeout succeeds when non-empty, else times out
501         */
502      public void testTimedPoll() {      public void testTimedPoll() {
503          try {          try {
504              ArrayBlockingQueue q = fullQueue(N);              ArrayBlockingQueue q = populatedQueue(SIZE);
505              for (int i = 0; i < N; ++i) {              for (int i = 0; i < SIZE; ++i) {
506                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
507              }              }
508              assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
509          } catch (InterruptedException e){          } catch (InterruptedException e){
510              fail("Unexpected exception");              unexpectedException();
511          }          }
512      }      }
513    
514        /**
515         * Interrupted timed poll throws InterruptedException instead of
516         * returning timeout status
517         */
518      public void testInterruptedTimedPoll(){      public void testInterruptedTimedPoll(){
519          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
520                  public void run() {                  public void run() {
521                      try {                      try {
522                          ArrayBlockingQueue q = fullQueue(N);                          ArrayBlockingQueue q = populatedQueue(SIZE);
523                          for (int i = 0; i < N; ++i) {                          for (int i = 0; i < SIZE; ++i) {
524                              assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
525                          }                          }
526                          assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
527                      } catch (InterruptedException success){                      } catch (InterruptedException success){
528                      }                      }
529                  }});                  }});
         t.start();  
530          try {          try {
531                t.start();
532             Thread.sleep(SHORT_DELAY_MS);             Thread.sleep(SHORT_DELAY_MS);
533             t.interrupt();             t.interrupt();
534             t.join();             t.join();
535          }          }
536          catch (InterruptedException ie) {          catch (InterruptedException ie) {
537              fail("Unexpected exception");              unexpectedException();
538          }          }
539      }      }
540    
541        /**
542         *  timed poll before a delayed offer fails; after offer succeeds;
543         *  on interruption throws
544         */
545      public void testTimedPollWithOffer(){      public void testTimedPollWithOffer(){
546          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
547          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
548                  public void run(){                  public void run(){
549                      try {                      try {
550                          assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
551                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
552                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
553                          fail("Should block");                          threadShouldThrow();
554                      } catch (InterruptedException success) { }                      } catch (InterruptedException success) { }
555                  }                  }
556              });              });
557          try {          try {
558              t.start();              t.start();
559              Thread.sleep(SHORT_DELAY_MS * 2);              Thread.sleep(SMALL_DELAY_MS);
560              assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
561              t.interrupt();              t.interrupt();
562              t.join();              t.join();
563          } catch (Exception e){          } catch (Exception e){
564              fail("Unexpected exception");              unexpectedException();
565          }          }
566      }      }
567    
568    
569        /**
570         * peek returns next element, or null if empty
571         */
572      public void testPeek(){      public void testPeek(){
573          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
574          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
575              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, ((Integer)q.peek()).intValue());
576              q.poll();              q.poll();
577              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
# Line 465  Line 580 
580          assertNull(q.peek());          assertNull(q.peek());
581      }      }
582    
583        /**
584         * element returns next element, or throws NSEE if empty
585         */
586      public void testElement(){      public void testElement(){
587          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
588          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
589              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, ((Integer)q.element()).intValue());
590              q.poll();              q.poll();
591          }          }
592          try {          try {
593              q.element();              q.element();
594              fail("no such element");              shouldThrow();
595          }          }
596          catch (NoSuchElementException success) {}          catch (NoSuchElementException success) {}
597      }      }
598    
599        /**
600         * remove removes next element, or throws NSEE if empty
601         */
602      public void testRemove(){      public void testRemove(){
603          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
604          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
605              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, ((Integer)q.remove()).intValue());
606          }          }
607          try {          try {
608              q.remove();              q.remove();
609              fail("remove should throw");              shouldThrow();
610          } catch (NoSuchElementException success){          } catch (NoSuchElementException success){
611          }          }
612      }      }
613    
614        /**
615         * remove(x) removes x and returns true if present
616         */
617      public void testRemoveElement(){      public void testRemoveElement(){
618          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
619          for (int i = 1; i < N; i+=2) {          for (int i = 1; i < SIZE; i+=2) {
620              assertTrue(q.remove(new Integer(i)));              assertTrue(q.remove(new Integer(i)));
621          }          }
622          for (int i = 0; i < N; i+=2) {          for (int i = 0; i < SIZE; i+=2) {
623              assertTrue(q.remove(new Integer(i)));              assertTrue(q.remove(new Integer(i)));
624              assertFalse(q.remove(new Integer(i+1)));              assertFalse(q.remove(new Integer(i+1)));
625          }          }
626          assert(q.isEmpty());          assertTrue(q.isEmpty());
627      }      }
628    
629        /**
630         * contains(x) reports true when elements added but not yet removed
631         */
632      public void testContains(){      public void testContains(){
633          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
634          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
635              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
636              q.poll();              q.poll();
637              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
638          }          }
639      }      }
640    
641        /**
642         * clear removes all elements
643         */
644      public void testClear(){      public void testClear(){
645          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
646          q.clear();          q.clear();
647          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
648          assertEquals(0, q.size());          assertEquals(0, q.size());
649          assertEquals(N, q.remainingCapacity());          assertEquals(SIZE, q.remainingCapacity());
650          q.add(new Integer(1));          q.add(one);
651          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
652          q.clear();          q.clear();
653          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
654      }      }
655    
656        /**
657         * containsAll(c) is true when c contains a subset of elements
658         */
659      public void testContainsAll(){      public void testContainsAll(){
660          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
661          ArrayBlockingQueue p = new ArrayBlockingQueue(N);          ArrayBlockingQueue p = new ArrayBlockingQueue(SIZE);
662          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
663              assertTrue(q.containsAll(p));              assertTrue(q.containsAll(p));
664              assertFalse(p.containsAll(q));              assertFalse(p.containsAll(q));
665              p.add(new Integer(i));              p.add(new Integer(i));
# Line 534  Line 667 
667          assertTrue(p.containsAll(q));          assertTrue(p.containsAll(q));
668      }      }
669    
670        /**
671         * retainAll(c) retains only those elements of c and reports true if changed
672         */
673      public void testRetainAll(){      public void testRetainAll(){
674          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
675          ArrayBlockingQueue p = fullQueue(N);          ArrayBlockingQueue p = populatedQueue(SIZE);
676          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
677              boolean changed = q.retainAll(p);              boolean changed = q.retainAll(p);
678              if (i == 0)              if (i == 0)
679                  assertFalse(changed);                  assertFalse(changed);
# Line 545  Line 681 
681                  assertTrue(changed);                  assertTrue(changed);
682    
683              assertTrue(q.containsAll(p));              assertTrue(q.containsAll(p));
684              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
685              p.remove();              p.remove();
686          }          }
687      }      }
688    
689        /**
690         * removeAll(c) removes only those elements of c and reports true if changed
691         */
692      public void testRemoveAll(){      public void testRemoveAll(){
693          for (int i = 1; i < N; ++i) {          for (int i = 1; i < SIZE; ++i) {
694              ArrayBlockingQueue q = fullQueue(N);              ArrayBlockingQueue q = populatedQueue(SIZE);
695              ArrayBlockingQueue p = fullQueue(i);              ArrayBlockingQueue p = populatedQueue(i);
696              assertTrue(q.removeAll(p));              assertTrue(q.removeAll(p));
697              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
698              for (int j = 0; j < i; ++j) {              for (int j = 0; j < i; ++j) {
699                  Integer I = (Integer)(p.remove());                  Integer I = (Integer)(p.remove());
700                  assertFalse(q.contains(I));                  assertFalse(q.contains(I));
# Line 563  Line 702 
702          }          }
703      }      }
704    
705        /**
706         *  toArray contains all elements
707         */
708      public void testToArray(){      public void testToArray(){
709          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
710          Object[] o = q.toArray();          Object[] o = q.toArray();
711          try {          try {
712          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
713              assertEquals(o[i], q.take());              assertEquals(o[i], q.take());
714          } catch (InterruptedException e){          } catch (InterruptedException e){
715              fail("Unexpected exception");              unexpectedException();
716          }          }
717      }      }
718    
719        /**
720         * toArray(a) contains all elements
721         */
722      public void testToArray2(){      public void testToArray2(){
723          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
724          Integer[] ints = new Integer[N];          Integer[] ints = new Integer[SIZE];
725          ints = (Integer[])q.toArray(ints);          ints = (Integer[])q.toArray(ints);
726          try {          try {
727              for(int i = 0; i < ints.length; i++)              for(int i = 0; i < ints.length; i++)
728                  assertEquals(ints[i], q.take());                  assertEquals(ints[i], q.take());
729          } catch (InterruptedException e){          } catch (InterruptedException e){
730              fail("Unexpected exception");              unexpectedException();
731            }
732        }
733    
734        /**
735         * toArray(null) throws NPE
736         */
737        public void testToArray_BadArg() {
738            try {
739                ArrayBlockingQueue q = populatedQueue(SIZE);
740                Object o[] = q.toArray(null);
741                shouldThrow();
742            } catch(NullPointerException success){}
743          }          }
744    
745        /**
746         * toArray with incompatable array type throws CCE
747         */
748        public void testToArray1_BadArg() {
749            try {
750                ArrayBlockingQueue q = populatedQueue(SIZE);
751                Object o[] = q.toArray(new String[10] );
752                shouldThrow();
753            } catch(ArrayStoreException  success){}
754      }      }
755    
756    
757        /**
758         * iterator iterates through all elements
759         */
760      public void testIterator(){      public void testIterator(){
761          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
762          Iterator it = q.iterator();          Iterator it = q.iterator();
763          try {          try {
764              while(it.hasNext()){              while(it.hasNext()){
765                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
766              }              }
767          } catch (InterruptedException e){          } catch (InterruptedException e){
768              fail("Unexpected exception");              unexpectedException();
769          }          }
770      }      }
771    
772      public void testIteratorOrdering() {      /**
773         * iterator.remove removes current element
774         */
775        public void testIteratorRemove () {
776          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
777            q.add(two);
778            q.add(one);
779            q.add(three);
780    
781            Iterator it = q.iterator();
782            it.next();
783            it.remove();
784    
785            it = q.iterator();
786            assertEquals(it.next(), one);
787            assertEquals(it.next(), three);
788            assertFalse(it.hasNext());
789        }
790    
791          q.add(new Integer(1));      /**
792          q.add(new Integer(2));       * iterator ordering is FIFO
793          q.add(new Integer(3));       */
794        public void testIteratorOrdering() {
795            final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
796            q.add(one);
797            q.add(two);
798            q.add(three);
799    
800          assertEquals("queue should be full", 0, q.remainingCapacity());          assertEquals("queue should be full", 0, q.remainingCapacity());
801    
802          int k = 0;          int k = 0;
803          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
804              int i = ((Integer)(it.next())).intValue();              int i = ((Integer)(it.next())).intValue();
805              assertEquals("items should come out in order", ++k, i);              assertEquals(++k, i);
806          }          }
807            assertEquals(3, k);
         assertEquals("should go through 3 elements", 3, k);  
808      }      }
809    
810        /**
811         * Modifications do not cause iterators to fail
812         */
813      public void testWeaklyConsistentIteration () {      public void testWeaklyConsistentIteration () {
   
814          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
815            q.add(one);
816          q.add(new Integer(1));          q.add(two);
817          q.add(new Integer(2));          q.add(three);
         q.add(new Integer(3));  
   
818          try {          try {
819              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
820                  q.remove();                  q.remove();
# Line 633  Line 822 
822              }              }
823          }          }
824          catch (ConcurrentModificationException e) {          catch (ConcurrentModificationException e) {
825              fail("weakly consistent iterator; should not get CME");              unexpectedException();
826          }          }
827            assertEquals(0, q.size());
         assertEquals("queue should be empty again", 0, q.size());  
828      }      }
829    
830    
831        /**
832         * toString contains toStrings of elements
833         */
834      public void testToString(){      public void testToString(){
835          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
836          String s = q.toString();          String s = q.toString();
837          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
838              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.indexOf(String.valueOf(i)) >= 0);
839          }          }
840      }      }
841    
842    
843        /**
844         * offer transfers elements across Executor tasks
845         */
846      public void testOfferInExecutor() {      public void testOfferInExecutor() {
   
847          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
848            q.add(one);
849          q.add(new Integer(1));          q.add(two);
         q.add(new Integer(2));  
   
850          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
   
851          executor.execute(new Runnable() {          executor.execute(new Runnable() {
852              public void run() {              public void run() {
853                  assertFalse("offer should be rejected", q.offer(new Integer(3)));                  threadAssertFalse(q.offer(three));
854                  try {                  try {
855                      assertTrue("offer should be accepted", q.offer(new Integer(3), MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
856                      assertEquals(0, q.remainingCapacity());                      threadAssertEquals(0, q.remainingCapacity());
857                  }                  }
858                  catch (InterruptedException e) {                  catch (InterruptedException e) {
859                      fail("should not be interrupted");                      threadUnexpectedException();
860                  }                  }
861              }              }
862          });          });
# Line 674  Line 864 
864          executor.execute(new Runnable() {          executor.execute(new Runnable() {
865              public void run() {              public void run() {
866                  try {                  try {
867                      Thread.sleep(MEDIUM_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
868                      assertEquals("first item in queue should be 1", new Integer(1), q.take());                      threadAssertEquals(one, q.take());
869                  }                  }
870                  catch (InterruptedException e) {                  catch (InterruptedException e) {
871                      fail("should not be interrupted");                      threadUnexpectedException();
872                  }                  }
873              }              }
874          });          });
875    
876          executor.shutdown();          joinPool(executor);
877    
878      }      }
879    
880        /**
881         * poll retrieves elements across Executor threads
882         */
883      public void testPollInExecutor() {      public void testPollInExecutor() {
   
884          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
   
885          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
   
886          executor.execute(new Runnable() {          executor.execute(new Runnable() {
887              public void run() {              public void run() {
888                  assertNull("poll should fail", q.poll());                  threadAssertNull(q.poll());
889                  try {                  try {
890                      assertTrue(null != q.poll(MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
891                      assertTrue(q.isEmpty());                      threadAssertTrue(q.isEmpty());
892                  }                  }
893                  catch (InterruptedException e) {                  catch (InterruptedException e) {
894                      fail("should not be interrupted");                      threadUnexpectedException();
895                  }                  }
896              }              }
897          });          });
# Line 709  Line 899 
899          executor.execute(new Runnable() {          executor.execute(new Runnable() {
900              public void run() {              public void run() {
901                  try {                  try {
902                      Thread.sleep(MEDIUM_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
903                      q.put(new Integer(1));                      q.put(one);
904                  }                  }
905                  catch (InterruptedException e) {                  catch (InterruptedException e) {
906                      fail("should not be interrupted");                      threadUnexpectedException();
907                    }
908                }
909            });
910    
911            joinPool(executor);
912        }
913    
914        /**
915         * A deserialized serialized queue has same elements in same order
916         */
917        public void testSerialization() {
918            ArrayBlockingQueue q = populatedQueue(SIZE);
919    
920            try {
921                ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
922                ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
923                out.writeObject(q);
924                out.close();
925    
926                ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
927                ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
928                ArrayBlockingQueue r = (ArrayBlockingQueue)in.readObject();
929                assertEquals(q.size(), r.size());
930                while (!q.isEmpty())
931                    assertEquals(q.remove(), r.remove());
932            } catch(Exception e){
933                unexpectedException();
934            }
935        }
936    
937        /**
938         * drainTo(null) throws NPE
939         */
940        public void testDrainToNull() {
941            ArrayBlockingQueue q = populatedQueue(SIZE);
942            try {
943                q.drainTo(null);
944                shouldThrow();
945            } catch(NullPointerException success) {
946            }
947        }
948    
949        /**
950         * drainTo(this) throws IAE
951         */
952        public void testDrainToSelf() {
953            ArrayBlockingQueue q = populatedQueue(SIZE);
954            try {
955                q.drainTo(q);
956                shouldThrow();
957            } catch(IllegalArgumentException success) {
958            }
959        }
960    
961        /**
962         * drainTo(c) empties queue into another collection c
963         */
964        public void testDrainTo() {
965            ArrayBlockingQueue q = populatedQueue(SIZE);
966            ArrayList l = new ArrayList();
967            q.drainTo(l);
968            assertEquals(q.size(), 0);
969            assertEquals(l.size(), SIZE);
970            for (int i = 0; i < SIZE; ++i)
971                assertEquals(l.get(i), new Integer(i));
972        }
973    
974        /**
975         * drainTo empties full queue, unblocking a waiting put.
976         */
977        public void testDrainToWithActivePut() {
978            final ArrayBlockingQueue q = populatedQueue(SIZE);
979            Thread t = new Thread(new Runnable() {
980                    public void run() {
981                        try {
982                            q.put(new Integer(SIZE+1));
983                        } catch (InterruptedException ie){
984                            threadUnexpectedException();
985                  }                  }
986              }              }
987          });          });
988            try {
989                t.start();
990                ArrayList l = new ArrayList();
991                q.drainTo(l);
992                assertTrue(l.size() >= SIZE);
993                for (int i = 0; i < SIZE; ++i)
994                    assertEquals(l.get(i), new Integer(i));
995                t.join();
996                assertTrue(q.size() + l.size() == SIZE+1);
997            } catch(Exception e){
998                unexpectedException();
999            }
1000        }
1001    
1002        /**
1003         * drainTo(null, n) throws NPE
1004         */
1005        public void testDrainToNullN() {
1006            ArrayBlockingQueue q = populatedQueue(SIZE);
1007            try {
1008                q.drainTo(null, 0);
1009                shouldThrow();
1010            } catch(NullPointerException success) {
1011            }
1012        }
1013    
1014          executor.shutdown();      /**
1015         * drainTo(this, n) throws IAE
1016         */
1017        public void testDrainToSelfN() {
1018            ArrayBlockingQueue q = populatedQueue(SIZE);
1019            try {
1020                q.drainTo(q, 0);
1021                shouldThrow();
1022            } catch(IllegalArgumentException success) {
1023            }
1024        }
1025    
1026        /**
1027         * drainTo(c, n) empties first max {n, size} elements of queue into c
1028         */
1029        public void testDrainToN() {
1030            for (int i = 0; i < SIZE + 2; ++i) {
1031                ArrayBlockingQueue q = populatedQueue(SIZE);
1032                ArrayList l = new ArrayList();
1033                q.drainTo(l, i);
1034                int k = (i < SIZE)? i : SIZE;
1035                assertEquals(q.size(), SIZE-k);
1036                assertEquals(l.size(), k);
1037                for (int j = 0; j < k; ++j)
1038                    assertEquals(l.get(j), new Integer(j));
1039            }
1040      }      }
1041    
1042    
1043  }  }

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.6

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8