[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.3, Sun Sep 14 20:42:40 2003 UTC revision 1.4, Sat Sep 20 18:20:07 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.*;  import java.io.*;
13    
14  public class ArrayBlockingQueueTest extends JSR166TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
   
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 35  Line 34 
34          return q;          return q;
35      }      }
36    
37        /**
38         *
39         */
40      public void testConstructor1(){      public void testConstructor1(){
41          assertEquals(SIZE, new ArrayBlockingQueue(SIZE).remainingCapacity());          assertEquals(SIZE, new ArrayBlockingQueue(SIZE).remainingCapacity());
42      }      }
43    
44        /**
45         *
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         *
57         */
58      public void testConstructor3(){      public void testConstructor3(){
59    
60          try {          try {
61              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);
62              fail("Cannot make from null collection");              shouldThrow();
63          }          }
64          catch (NullPointerException success) {}          catch (NullPointerException success) {}
65      }      }
66    
67        /**
68         *
69         */
70      public void testConstructor4(){      public void testConstructor4(){
71          try {          try {
72              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
73              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
74              fail("Cannot make with null elements");              shouldThrow();
75          }          }
76          catch (NullPointerException success) {}          catch (NullPointerException success) {}
77      }      }
78    
79        /**
80         *
81         */
82      public void testConstructor5(){      public void testConstructor5(){
83          try {          try {
84              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
85              for (int i = 0; i < SIZE-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
86                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
87              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
88              fail("Cannot make with null elements");              shouldThrow();
89          }          }
90          catch (NullPointerException success) {}          catch (NullPointerException success) {}
91      }      }
92    
93        /**
94         *
95         */
96      public void testConstructor6(){      public void testConstructor6(){
97          try {          try {
98              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
99              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
100                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
101              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));
102              fail("Cannot make with insufficient capacity");              shouldThrow();
103          }          }
104          catch (IllegalArgumentException success) {}          catch (IllegalArgumentException success) {}
105      }      }
106    
107        /**
108         *
109         */
110      public void testConstructor7(){      public void testConstructor7(){
111          try {          try {
112              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
# Line 99  Line 119 
119          finally {}          finally {}
120      }      }
121    
122        /**
123         *
124         */
125      public void testEmptyFull() {      public void testEmptyFull() {
126          ArrayBlockingQueue q = new ArrayBlockingQueue(2);          ArrayBlockingQueue q = new ArrayBlockingQueue(2);
127          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
128          assertEquals("should have room for 2", 2, q.remainingCapacity());          assertEquals(2, q.remainingCapacity());
129          q.add(one);          q.add(one);
130          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
131          q.add(two);          q.add(two);
132          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
133          assertEquals("queue should be full", 0, q.remainingCapacity());          assertEquals(0, q.remainingCapacity());
134          assertFalse("offer should be rejected", q.offer(three));          assertFalse(q.offer(three));
135      }      }
136    
137        /**
138         *
139         */
140      public void testRemainingCapacity(){      public void testRemainingCapacity(){
141          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
142          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 125  Line 151 
151          }          }
152      }      }
153    
154        /**
155         *
156         */
157      public void testOfferNull(){      public void testOfferNull(){
158          try {          try {
159              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
160              q.offer(null);              q.offer(null);
161              fail("should throw NPE");              shouldThrow();
162          } catch (NullPointerException success) { }          } catch (NullPointerException success) { }
163      }      }
164    
165        /**
166         *
167         */
168      public void testOffer(){      public void testOffer(){
169          ArrayBlockingQueue q = new ArrayBlockingQueue(1);          ArrayBlockingQueue q = new ArrayBlockingQueue(1);
170          assertTrue(q.offer(zero));          assertTrue(q.offer(zero));
171          assertFalse(q.offer(one));          assertFalse(q.offer(one));
172      }      }
173    
174        /**
175         *
176         */
177      public void testAdd(){      public void testAdd(){
178          try {          try {
179              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
# Line 151  Line 186 
186          }          }
187      }      }
188    
189        /**
190         *
191         */
192      public void testAddAll1(){      public void testAddAll1(){
193          try {          try {
194              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
195              q.addAll(null);              q.addAll(null);
196              fail("Cannot add null collection");              shouldThrow();
197          }          }
198          catch (NullPointerException success) {}          catch (NullPointerException success) {}
199      }      }
200        /**
201         *
202         */
203      public void testAddAll2(){      public void testAddAll2(){
204          try {          try {
205              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
206              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
207              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
208              fail("Cannot add null elements");              shouldThrow();
209          }          }
210          catch (NullPointerException success) {}          catch (NullPointerException success) {}
211      }      }
212        /**
213         *
214         */
215      public void testAddAll3(){      public void testAddAll3(){
216          try {          try {
217              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
# Line 175  Line 219 
219              for (int i = 0; i < SIZE-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
220                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
221              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
222              fail("Cannot add null elements");              shouldThrow();
223          }          }
224          catch (NullPointerException success) {}          catch (NullPointerException success) {}
225      }      }
226        /**
227         *
228         */
229      public void testAddAll4(){      public void testAddAll4(){
230          try {          try {
231              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
# Line 186  Line 233 
233              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
234                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
235              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
236              fail("Cannot add with insufficient capacity");              shouldThrow();
237          }          }
238          catch (IllegalStateException success) {}          catch (IllegalStateException success) {}
239      }      }
240        /**
241         *
242         */
243      public void testAddAll5(){      public void testAddAll5(){
244          try {          try {
245              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
# Line 205  Line 255 
255          finally {}          finally {}
256      }      }
257    
258        /**
259         *
260         */
261       public void testPutNull() {       public void testPutNull() {
262          try {          try {
263              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
264              q.put(null);              q.put(null);
265              fail("put should throw NPE");              shouldThrow();
266          }          }
267          catch (NullPointerException success){          catch (NullPointerException success){
268          }          }
269          catch (InterruptedException ie) {          catch (InterruptedException ie) {
270              fail("Unexpected exception");              unexpectedException();
271          }          }
272       }       }
273    
274        /**
275         *
276         */
277       public void testPut() {       public void testPut() {
278           try {           try {
279               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
# Line 229  Line 285 
285               assertEquals(0, q.remainingCapacity());               assertEquals(0, q.remainingCapacity());
286           }           }
287          catch (InterruptedException ie) {          catch (InterruptedException ie) {
288              fail("Unexpected exception");              unexpectedException();
289          }          }
290      }      }
291    
292        /**
293         *
294         */
295      public void testBlockingPut(){      public void testBlockingPut(){
296          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
297                  public void run() {                  public void run() {
# Line 244  Line 303 
303                              ++added;                              ++added;
304                          }                          }
305                          q.put(new Integer(SIZE));                          q.put(new Integer(SIZE));
306                          threadFail("put should block");                          threadShouldThrow();
307                      } catch (InterruptedException ie){                      } catch (InterruptedException ie){
308                          threadAssertEquals(added, SIZE);                          threadAssertEquals(added, SIZE);
309                      }                      }
# Line 256  Line 315 
315             t.join();             t.join();
316          }          }
317          catch (InterruptedException ie) {          catch (InterruptedException ie) {
318              fail("Unexpected exception");              unexpectedException();
319          }          }
320      }      }
321    
322        /**
323         *
324         */
325      public void testPutWithTake() {      public void testPutWithTake() {
326          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
327          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 274  Line 336 
336                          ++added;                          ++added;
337                          q.put(new Object());                          q.put(new Object());
338                          ++added;                          ++added;
339                          threadFail("Should block");                          threadShouldThrow();
340                      } catch (InterruptedException e){                      } catch (InterruptedException e){
341                          threadAssertTrue(added >= 2);                          threadAssertTrue(added >= 2);
342                      }                      }
# Line 287  Line 349 
349              t.interrupt();              t.interrupt();
350              t.join();              t.join();
351          } catch (Exception e){          } catch (Exception e){
352              fail("Unexpected exception");              unexpectedException();
353          }          }
354      }      }
355    
356        /**
357         *
358         */
359      public void testTimedOffer() {      public void testTimedOffer() {
360          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
361          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 300  Line 365 
365                          q.put(new Object());                          q.put(new Object());
366                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
367                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
368                          threadFail("Should block");                          threadShouldThrow();
369                      } catch (InterruptedException success){}                      } catch (InterruptedException success){}
370                  }                  }
371              });              });
# Line 311  Line 376 
376              t.interrupt();              t.interrupt();
377              t.join();              t.join();
378          } catch (Exception e){          } catch (Exception e){
379              fail("Unexpected exception");              unexpectedException();
380          }          }
381      }      }
382    
383        /**
384         *
385         */
386      public void testTake(){      public void testTake(){
387          try {          try {
388              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 322  Line 390 
390                  assertEquals(i, ((Integer)q.take()).intValue());                  assertEquals(i, ((Integer)q.take()).intValue());
391              }              }
392          } catch (InterruptedException e){          } catch (InterruptedException e){
393              fail("Unexpected exception");              unexpectedException();
394          }          }
395      }      }
396    
397        /**
398         *
399         */
400      public void testTakeFromEmpty() {      public void testTakeFromEmpty() {
401          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
402          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
403                  public void run(){                  public void run(){
404                      try {                      try {
405                          q.take();                          q.take();
406                          threadFail("Should block");                          threadShouldThrow();
407                      } catch (InterruptedException success){ }                      } catch (InterruptedException success){ }
408                  }                  }
409              });              });
# Line 342  Line 413 
413              t.interrupt();              t.interrupt();
414              t.join();              t.join();
415          } catch (Exception e){          } catch (Exception e){
416              fail("Unexpected exception");              unexpectedException();
417          }          }
418      }      }
419    
420        /**
421         *
422         */
423      public void testBlockingTake(){      public void testBlockingTake(){
424          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
425                  public void run() {                  public void run() {
# Line 355  Line 429 
429                              threadAssertEquals(i, ((Integer)q.take()).intValue());                              threadAssertEquals(i, ((Integer)q.take()).intValue());
430                          }                          }
431                          q.take();                          q.take();
432                          threadFail("take should block");                          threadShouldThrow();
433                      } catch (InterruptedException success){                      } catch (InterruptedException success){
434                      }                      }
435                  }});                  }});
# Line 366  Line 440 
440              t.join();              t.join();
441          }          }
442          catch (InterruptedException ie) {          catch (InterruptedException ie) {
443              fail("Unexpected exception");              unexpectedException();
444          }          }
445      }      }
446    
447    
448        /**
449         *
450         */
451      public void testPoll(){      public void testPoll(){
452          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
453          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 379  Line 456 
456          assertNull(q.poll());          assertNull(q.poll());
457      }      }
458    
459        /**
460         *
461         */
462      public void testTimedPoll0() {      public void testTimedPoll0() {
463          try {          try {
464              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 387  Line 467 
467              }              }
468              assertNull(q.poll(0, TimeUnit.MILLISECONDS));              assertNull(q.poll(0, TimeUnit.MILLISECONDS));
469          } catch (InterruptedException e){          } catch (InterruptedException e){
470              fail("Unexpected exception");              unexpectedException();
471          }          }
472      }      }
473    
474        /**
475         *
476         */
477      public void testTimedPoll() {      public void testTimedPoll() {
478          try {          try {
479              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 399  Line 482 
482              }              }
483              assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
484          } catch (InterruptedException e){          } catch (InterruptedException e){
485              fail("Unexpected exception");              unexpectedException();
486          }          }
487      }      }
488    
489        /**
490         *
491         */
492      public void testInterruptedTimedPoll(){      public void testInterruptedTimedPoll(){
493          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
494                  public void run() {                  public void run() {
# Line 422  Line 508 
508              t.join();              t.join();
509          }          }
510          catch (InterruptedException ie) {          catch (InterruptedException ie) {
511              fail("Unexpected exception");              unexpectedException();
512          }          }
513      }      }
514    
515        /**
516         *
517         */
518      public void testTimedPollWithOffer(){      public void testTimedPollWithOffer(){
519          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
520          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 434  Line 523 
523                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
524                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
525                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
526                          threadFail("Should block");                          threadShouldThrow();
527                      } catch (InterruptedException success) { }                      } catch (InterruptedException success) { }
528                  }                  }
529              });              });
# Line 445  Line 534 
534              t.interrupt();              t.interrupt();
535              t.join();              t.join();
536          } catch (Exception e){          } catch (Exception e){
537              fail("Unexpected exception");              unexpectedException();
538          }          }
539      }      }
540    
541    
542        /**
543         *
544         */
545      public void testPeek(){      public void testPeek(){
546          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
547          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 461  Line 553 
553          assertNull(q.peek());          assertNull(q.peek());
554      }      }
555    
556        /**
557         *
558         */
559      public void testElement(){      public void testElement(){
560          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
561          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 469  Line 564 
564          }          }
565          try {          try {
566              q.element();              q.element();
567              fail("no such element");              shouldThrow();
568          }          }
569          catch (NoSuchElementException success) {}          catch (NoSuchElementException success) {}
570      }      }
571    
572        /**
573         *
574         */
575      public void testRemove(){      public void testRemove(){
576          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
577          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 481  Line 579 
579          }          }
580          try {          try {
581              q.remove();              q.remove();
582              fail("remove should throw");              shouldThrow();
583          } catch (NoSuchElementException success){          } catch (NoSuchElementException success){
584          }          }
585      }      }
586    
587        /**
588         *
589         */
590      public void testRemoveElement(){      public void testRemoveElement(){
591          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
592          for (int i = 1; i < SIZE; i+=2) {          for (int i = 1; i < SIZE; i+=2) {
# Line 498  Line 599 
599          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
600      }      }
601    
602        /**
603         *
604         */
605      public void testContains(){      public void testContains(){
606          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
607          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 507  Line 611 
611          }          }
612      }      }
613    
614        /**
615         *
616         */
617      public void testClear(){      public void testClear(){
618          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
619          q.clear();          q.clear();
# Line 519  Line 626 
626          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
627      }      }
628    
629        /**
630         *
631         */
632      public void testContainsAll(){      public void testContainsAll(){
633          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
634          ArrayBlockingQueue p = new ArrayBlockingQueue(SIZE);          ArrayBlockingQueue p = new ArrayBlockingQueue(SIZE);
# Line 530  Line 640 
640          assertTrue(p.containsAll(q));          assertTrue(p.containsAll(q));
641      }      }
642    
643        /**
644         *
645         */
646      public void testRetainAll(){      public void testRetainAll(){
647          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
648          ArrayBlockingQueue p = populatedQueue(SIZE);          ArrayBlockingQueue p = populatedQueue(SIZE);
# Line 546  Line 659 
659          }          }
660      }      }
661    
662        /**
663         *
664         */
665      public void testRemoveAll(){      public void testRemoveAll(){
666          for (int i = 1; i < SIZE; ++i) {          for (int i = 1; i < SIZE; ++i) {
667              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 560  Line 676 
676      }      }
677    
678    
679        /**
680         *
681         */
682      public void testToArray(){      public void testToArray(){
683          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
684          Object[] o = q.toArray();          Object[] o = q.toArray();
# Line 567  Line 686 
686          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
687              assertEquals(o[i], q.take());              assertEquals(o[i], q.take());
688          } catch (InterruptedException e){          } catch (InterruptedException e){
689              fail("Unexpected exception");              unexpectedException();
690          }          }
691      }      }
692    
693        /**
694         *
695         */
696      public void testToArray2(){      public void testToArray2(){
697          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
698          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
# Line 579  Line 701 
701              for(int i = 0; i < ints.length; i++)              for(int i = 0; i < ints.length; i++)
702                  assertEquals(ints[i], q.take());                  assertEquals(ints[i], q.take());
703          } catch (InterruptedException e){          } catch (InterruptedException e){
704              fail("Unexpected exception");              unexpectedException();
705          }          }
706      }      }
707    
708        /**
709         *
710         */
711      public void testIterator(){      public void testIterator(){
712          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
713          Iterator it = q.iterator();          Iterator it = q.iterator();
# Line 591  Line 716 
716                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
717              }              }
718          } catch (InterruptedException e){          } catch (InterruptedException e){
719              fail("Unexpected exception");              unexpectedException();
720          }          }
721      }      }
722    
723        /**
724         *
725         */
726      public void testIteratorOrdering() {      public void testIteratorOrdering() {
   
727          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
   
728          q.add(one);          q.add(one);
729          q.add(two);          q.add(two);
730          q.add(three);          q.add(three);
# Line 608  Line 734 
734          int k = 0;          int k = 0;
735          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
736              int i = ((Integer)(it.next())).intValue();              int i = ((Integer)(it.next())).intValue();
737              assertEquals("items should come out in order", ++k, i);              assertEquals(++k, i);
738          }          }
739            assertEquals(3, k);
         assertEquals("should go through 3 elements", 3, k);  
740      }      }
741    
742        /**
743         *
744         */
745      public void testWeaklyConsistentIteration () {      public void testWeaklyConsistentIteration () {
   
746          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
   
747          q.add(one);          q.add(one);
748          q.add(two);          q.add(two);
749          q.add(three);          q.add(three);
   
750          try {          try {
751              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
752                  q.remove();                  q.remove();
# Line 629  Line 754 
754              }              }
755          }          }
756          catch (ConcurrentModificationException e) {          catch (ConcurrentModificationException e) {
757              fail("weakly consistent iterator; should not get CME");              unexpectedException();
758          }          }
759    
760          assertEquals("queue should be empty again", 0, q.size());          assertEquals(0, q.size());
761      }      }
762    
763    
764        /**
765         *
766         */
767      public void testToString(){      public void testToString(){
768          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
769          String s = q.toString();          String s = q.toString();
# Line 645  Line 773 
773      }      }
774    
775    
776        /**
777         *
778         */
779      public void testOfferInExecutor() {      public void testOfferInExecutor() {
780    
781          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
# Line 662  Line 793 
793                      threadAssertEquals(0, q.remainingCapacity());                      threadAssertEquals(0, q.remainingCapacity());
794                  }                  }
795                  catch (InterruptedException e) {                  catch (InterruptedException e) {
796                      threadFail("should not be interrupted");                      threadUnexpectedException();
797                  }                  }
798              }              }
799          });          });
# Line 674  Line 805 
805                      threadAssertEquals(one, q.take());                      threadAssertEquals(one, q.take());
806                  }                  }
807                  catch (InterruptedException e) {                  catch (InterruptedException e) {
808                      threadFail("should not be interrupted");                      threadUnexpectedException();
809                  }                  }
810              }              }
811          });          });
# Line 683  Line 814 
814    
815      }      }
816    
817        /**
818         *
819         */
820      public void testPollInExecutor() {      public void testPollInExecutor() {
821    
822          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
# Line 697  Line 831 
831                      threadAssertTrue(q.isEmpty());                      threadAssertTrue(q.isEmpty());
832                  }                  }
833                  catch (InterruptedException e) {                  catch (InterruptedException e) {
834                      threadFail("should not be interrupted");                      threadUnexpectedException();
835                  }                  }
836              }              }
837          });          });
# Line 709  Line 843 
843                      q.put(one);                      q.put(one);
844                  }                  }
845                  catch (InterruptedException e) {                  catch (InterruptedException e) {
846                      threadFail("should not be interrupted");                      threadUnexpectedException();
847                  }                  }
848              }              }
849          });          });
# Line 718  Line 852 
852    
853      }      }
854    
855        /**
856         *
857         */
858      public void testSerialization() {      public void testSerialization() {
859          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
860    
# Line 734  Line 871 
871              while (!q.isEmpty())              while (!q.isEmpty())
872                  assertEquals(q.remove(), r.remove());                  assertEquals(q.remove(), r.remove());
873          } catch(Exception e){          } catch(Exception e){
874              fail("unexpected exception");              unexpectedException();
875          }          }
876      }      }
877    

Legend:
Removed from v.1.3  
changed lines
  Added in v.1.4

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8