[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.4, Sat Sep 20 18:20:07 2003 UTC revision 1.6, Sun Oct 5 23:00:39 2003 UTC
# Line 35  Line 35 
35      }      }
36    
37      /**      /**
38       *       * A new queue has the indicated capacity
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       *       * Constructor throws IAE if  capacity argument nonpositive
46       */       */
47      public void testConstructor2() {      public void testConstructor2() {
48          try {          try {
# Line 53  Line 53 
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              shouldThrow();              shouldThrow();
# Line 65  Line 64 
64      }      }
65    
66      /**      /**
67       *       * Initializing from Collection of null elements throws NPE
68       */       */
69      public void testConstructor4() {      public void testConstructor4() {
70          try {          try {
# Line 77  Line 76 
76      }      }
77    
78      /**      /**
79       *       * Initializing from Collection with some null elements throws NPE
80       */       */
81      public void testConstructor5() {      public void testConstructor5() {
82          try {          try {
# Line 91  Line 90 
90      }      }
91    
92      /**      /**
93       *       * Initializing from too large collection throws IAE
94       */       */
95      public void testConstructor6() {      public void testConstructor6() {
96          try {          try {
# Line 105  Line 104 
104      }      }
105    
106      /**      /**
107       *       * Queue contains all elements of collection used to initialize
108       */       */
109      public void testConstructor7() {      public void testConstructor7() {
110          try {          try {
# Line 120  Line 119 
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);
# Line 135  Line 134 
134      }      }
135    
136      /**      /**
137       *       * remainingCapacity decreases on add, increases on remove
138       */       */
139      public void testRemainingCapacity() {      public void testRemainingCapacity() {
140          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 152  Line 151 
151      }      }
152    
153      /**      /**
154       *       *  offer(null) throws NPE
155       */       */
156      public void testOfferNull() {      public void testOfferNull() {
157          try {          try {
# Line 163  Line 162 
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) { }
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);
# Line 172  Line 182 
182      }      }
183    
184      /**      /**
185       *       * add succeeds if not full; throws ISE if full
186       */       */
187      public void testAdd() {      public void testAdd() {
188          try {          try {
# Line 187  Line 197 
197      }      }
198    
199      /**      /**
200       *       *  addAll(null) throws NPE
201       */       */
202      public void testAddAll1() {      public void testAddAll1() {
203          try {          try {
# Line 197  Line 207 
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 {
# Line 210  Line 234 
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 {
# Line 224  Line 249 
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 {
# Line 238  Line 263 
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 {
# Line 256  Line 281 
281      }      }
282    
283      /**      /**
284       *       *  put(null) throws NPE
285       */       */
286       public void testPutNull() {       public void testPutNull() {
287          try {          try {
# Line 272  Line 297 
297       }       }
298    
299      /**      /**
300       *       * all elements successfully put are contained
301       */       */
302       public void testPut() {       public void testPut() {
303           try {           try {
# Line 290  Line 315 
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() {
# Line 320  Line 345 
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);
# Line 354  Line 379 
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);
# Line 381  Line 406 
406      }      }
407    
408      /**      /**
409       *       * take retrieves elements in FIFO order
410       */       */
411      public void testTake() {      public void testTake() {
412          try {          try {
# Line 395  Line 420 
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);
# Line 418  Line 443 
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() {
# Line 446  Line 471 
471    
472    
473      /**      /**
474       *       * poll succeeds unless empty
475       */       */
476      public void testPoll() {      public void testPoll() {
477          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 457  Line 482 
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 {
# Line 472  Line 497 
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 {
# Line 487  Line 512 
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() {
# Line 513  Line 539 
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);
# Line 540  Line 567 
567    
568    
569      /**      /**
570       *       * peek returns next element, or null if empty
571       */       */
572      public void testPeek() {      public void testPeek() {
573          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 554  Line 581 
581      }      }
582    
583      /**      /**
584       *       * element returns next element, or throws NSEE if empty
585       */       */
586      public void testElement() {      public void testElement() {
587          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 570  Line 597 
597      }      }
598    
599      /**      /**
600       *       * remove removes next element, or throws NSEE if empty
601       */       */
602      public void testRemove() {      public void testRemove() {
603          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 585  Line 612 
612      }      }
613    
614      /**      /**
615       *       * remove(x) removes x and returns true if present
616       */       */
617      public void testRemoveElement() {      public void testRemoveElement() {
618          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 600  Line 627 
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 = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 612  Line 639 
639      }      }
640    
641      /**      /**
642       *       * clear removes all elements
643       */       */
644      public void testClear() {      public void testClear() {
645          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 627  Line 654 
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 = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 641  Line 668 
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 = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 660  Line 687 
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 < SIZE; ++i) {          for (int i = 1; i < SIZE; ++i) {
# Line 675  Line 702 
702          }          }
703      }      }
704    
   
705      /**      /**
706       *       *  toArray contains all elements
707       */       */
708      public void testToArray() {      public void testToArray() {
709          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 691  Line 717 
717      }      }
718    
719      /**      /**
720       *       * toArray(a) contains all elements
721       */       */
722      public void testToArray2() {      public void testToArray2() {
723          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 706  Line 732 
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 = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 721  Line 770 
770      }      }
771    
772      /**      /**
773       *       * iterator.remove removes current element
774         */
775        public void testIteratorRemove () {
776            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        /**
792         * iterator ordering is FIFO
793       */       */
794      public void testIteratorOrdering() {      public void testIteratorOrdering() {
795          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
# Line 740  Line 808 
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);
# Line 756  Line 824 
824          catch (ConcurrentModificationException e) {          catch (ConcurrentModificationException e) {
825              unexpectedException();              unexpectedException();
826          }          }
   
827          assertEquals(0, q.size());          assertEquals(0, q.size());
828      }      }
829    
830    
831      /**      /**
832       *       * toString contains toStrings of elements
833       */       */
834      public void testToString() {      public void testToString() {
835          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 774  Line 841 
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);          q.add(one);
849          q.add(two);          q.add(two);
   
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                  threadAssertFalse(q.offer(three));                  threadAssertFalse(q.offer(three));
# Line 815  Line 878 
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                  threadAssertNull(q.poll());                  threadAssertNull(q.poll());
# Line 849  Line 909 
909          });          });
910    
911          joinPool(executor);          joinPool(executor);
   
912      }      }
913    
914      /**      /**
915       *       * A deserialized serialized queue has same elements in same order
916       */       */
917      public void testSerialization() {      public void testSerialization() {
918          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 875  Line 934 
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        /**
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.4  
changed lines
  Added in v.1.6

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8