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

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

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

revision 1.15, Wed Dec 23 00:49:44 2009 UTC revision 1.16, Wed Aug 25 01:46:24 2010 UTC
# Line 5  Line 5 
5   */   */
6    
7  import junit.framework.*;  import junit.framework.*;
8    import java.io.BufferedInputStream;
9    import java.io.BufferedOutputStream;
10    import java.io.ByteArrayInputStream;
11    import java.io.ByteArrayOutputStream;
12    import java.io.ObjectInputStream;
13    import java.io.ObjectOutputStream;
14  import java.util.*;  import java.util.*;
 import java.util.concurrent.*;  
15    
16  public class ArrayDequeTest extends JSR166TestCase {  public class ArrayDequeTest extends JSR166TestCase {
17      public static void main(String[] args) {      public static void main(String[] args) {
# Line 18  Line 23 
23      }      }
24    
25      /**      /**
26       * Create a queue of given size containing consecutive       * Create a deque of given size containing consecutive
27       * Integers 0 ... n.       * Integers 0 ... n.
28       */       */
29      private ArrayDeque populatedDeque(int n) {      private ArrayDeque populatedDeque(int n) {
# Line 32  Line 37 
37      }      }
38    
39      /**      /**
40       * new queue is empty       * new deque is empty
41       */       */
42      public void testConstructor1() {      public void testConstructor1() {
43          assertEquals(0, new ArrayDeque().size());          assertEquals(0, new ArrayDeque().size());
# Line 49  Line 54 
54      }      }
55    
56      /**      /**
57       * Queue contains all elements of collection used to initialize       * Initializing from Collection of null elements throws NPE
58         */
59        public void testConstructor4() {
60            try {
61                Integer[] ints = new Integer[SIZE];
62                ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
63                shouldThrow();
64            } catch (NullPointerException success) {}
65        }
66    
67        /**
68         * Initializing from Collection with some null elements throws NPE
69         */
70        public void testConstructor5() {
71            try {
72                Integer[] ints = new Integer[SIZE];
73                for (int i = 0; i < SIZE-1; ++i)
74                    ints[i] = new Integer(i);
75                ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
76                shouldThrow();
77            } catch (NullPointerException success) {}
78        }
79    
80        /**
81         * Deque contains all elements of collection used to initialize
82       */       */
83      public void testConstructor6() {      public void testConstructor6() {
84          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
# Line 102  Line 130 
130      }      }
131    
132      /**      /**
133       * peekFirst returns element inserted with push       * peekFirst() returns element inserted with push
134       */       */
135      public void testPush() {      public void testPush() {
136          ArrayDeque q = populatedDeque(3);          ArrayDeque q = populatedDeque(3);
# Line 112  Line 140 
140      }      }
141    
142      /**      /**
143       *  pop removes next element, or throws NSEE if empty       * pop() removes next element, or throws NSEE if empty
144       */       */
145      public void testPop() {      public void testPop() {
146          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 128  Line 156 
156      /**      /**
157       * offer(null) throws NPE       * offer(null) throws NPE
158       */       */
159        public void testOfferNull() {
160            try {
161                ArrayDeque q = new ArrayDeque();
162                q.offer(null);
163                shouldThrow();
164            } catch (NullPointerException success) {}
165        }
166    
167        /**
168         * offerFirst(null) throws NPE
169         */
170      public void testOfferFirstNull() {      public void testOfferFirstNull() {
171          try {          try {
172              ArrayDeque q = new ArrayDeque();              ArrayDeque q = new ArrayDeque();
# Line 137  Line 176 
176      }      }
177    
178      /**      /**
179       * OfferFirst succeeds       * offerLast(null) throws NPE
180         */
181        public void testOfferLastNull() {
182            try {
183                ArrayDeque q = new ArrayDeque();
184                q.offerLast(null);
185                shouldThrow();
186            } catch (NullPointerException success) {}
187        }
188    
189        /**
190         * offer(x) succeeds
191         */
192        public void testOffer() {
193            ArrayDeque q = new ArrayDeque();
194            assertTrue(q.offer(zero));
195            assertTrue(q.offer(one));
196            assertSame(zero, q.peekFirst());
197            assertSame(one, q.peekLast());
198        }
199    
200        /**
201         * offerFirst(x) succeeds
202       */       */
203      public void testOfferFirst() {      public void testOfferFirst() {
204          ArrayDeque q = new ArrayDeque();          ArrayDeque q = new ArrayDeque();
205          assertTrue(q.offerFirst(new Integer(0)));          assertTrue(q.offerFirst(zero));
206          assertTrue(q.offerFirst(new Integer(1)));          assertTrue(q.offerFirst(one));
207            assertSame(one, q.peekFirst());
208            assertSame(zero, q.peekLast());
209      }      }
210    
211      /**      /**
212       * OfferLast succeeds       * offerLast(x) succeeds
213       */       */
214      public void testOfferLast() {      public void testOfferLast() {
215          ArrayDeque q = new ArrayDeque();          ArrayDeque q = new ArrayDeque();
216          assertTrue(q.offerLast(new Integer(0)));          assertTrue(q.offerLast(zero));
217          assertTrue(q.offerLast(new Integer(1)));          assertTrue(q.offerLast(one));
218            assertSame(zero, q.peekFirst());
219            assertSame(one, q.peekLast());
220        }
221    
222        /**
223         * add(null) throws NPE
224         */
225        public void testAddNull() {
226            try {
227                ArrayDeque q = new ArrayDeque();
228                q.add(null);
229                shouldThrow();
230            } catch (NullPointerException success) {}
231      }      }
232    
233      /**      /**
234       * add succeeds       * addFirst(null) throws NPE
235         */
236        public void testAddFirstNull() {
237            try {
238                ArrayDeque q = new ArrayDeque();
239                q.addFirst(null);
240                shouldThrow();
241            } catch (NullPointerException success) {}
242        }
243    
244        /**
245         * addLast(null) throws NPE
246         */
247        public void testAddLastNull() {
248            try {
249                ArrayDeque q = new ArrayDeque();
250                q.addLast(null);
251                shouldThrow();
252            } catch (NullPointerException success) {}
253        }
254    
255        /**
256         * add(x) succeeds
257       */       */
258      public void testAdd() {      public void testAdd() {
259          ArrayDeque q = new ArrayDeque();          ArrayDeque q = new ArrayDeque();
260          for (int i = 0; i < SIZE; ++i) {          assertTrue(q.add(zero));
261              assertEquals(i, q.size());          assertTrue(q.add(one));
262              assertTrue(q.add(new Integer(i)));          assertSame(zero, q.peekFirst());
263            assertSame(one, q.peekLast());
264          }          }
265    
266        /**
267         * addFirst(x) succeeds
268         */
269        public void testAddFirst() {
270            ArrayDeque q = new ArrayDeque();
271            q.addFirst(zero);
272            q.addFirst(one);
273            assertSame(one, q.peekFirst());
274            assertSame(zero, q.peekLast());
275        }
276    
277        /**
278         * addLast(x) succeeds
279         */
280        public void testAddLast() {
281            ArrayDeque q = new ArrayDeque();
282            q.addLast(zero);
283            q.addLast(one);
284            assertSame(zero, q.peekFirst());
285            assertSame(one, q.peekLast());
286      }      }
287    
288      /**      /**
# Line 177  Line 297 
297      }      }
298    
299      /**      /**
300       * Queue contains all elements, in traversal order, of successful addAll       * addAll of a collection with null elements throws NPE
301         */
302        public void testAddAll2() {
303            try {
304                ArrayDeque q = new ArrayDeque();
305                Integer[] ints = new Integer[SIZE];
306                q.addAll(Arrays.asList(ints));
307                shouldThrow();
308            } catch (NullPointerException success) {}
309        }
310    
311        /**
312         * addAll of a collection with any null elements throws NPE after
313         * possibly adding some elements
314         */
315        public void testAddAll3() {
316            try {
317                ArrayDeque q = new ArrayDeque();
318                Integer[] ints = new Integer[SIZE];
319                for (int i = 0; i < SIZE-1; ++i)
320                    ints[i] = new Integer(i);
321                q.addAll(Arrays.asList(ints));
322                shouldThrow();
323            } catch (NullPointerException success) {}
324        }
325    
326        /**
327         * Deque contains all elements, in traversal order, of successful addAll
328       */       */
329      public void testAddAll5() {      public void testAddAll5() {
330          Integer[] empty = new Integer[0];          Integer[] empty = new Integer[0];
# Line 192  Line 339 
339      }      }
340    
341      /**      /**
342       *  pollFirst succeeds unless empty       * pollFirst() succeeds unless empty
343       */       */
344      public void testPollFirst() {      public void testPollFirst() {
345          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 203  Line 350 
350      }      }
351    
352      /**      /**
353       *  pollLast succeeds unless empty       * pollLast() succeeds unless empty
354       */       */
355      public void testPollLast() {      public void testPollLast() {
356          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 214  Line 361 
361      }      }
362    
363      /**      /**
364       *  poll succeeds unless empty       * poll() succeeds unless empty
365       */       */
366      public void testPoll() {      public void testPoll() {
367          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 225  Line 372 
372      }      }
373    
374      /**      /**
375       *  remove removes next element, or throws NSEE if empty       * remove() removes next element, or throws NSEE if empty
376       */       */
377      public void testRemove() {      public void testRemove() {
378          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 239  Line 386 
386      }      }
387    
388      /**      /**
389       *  peekFirst returns next element, or null if empty       * remove(x) removes x and returns true if present
390         */
391        public void testRemoveElement() {
392            ArrayDeque q = populatedDeque(SIZE);
393            for (int i = 1; i < SIZE; i+=2) {
394                assertTrue(q.remove(new Integer(i)));
395            }
396            for (int i = 0; i < SIZE; i+=2) {
397                assertTrue(q.remove(new Integer(i)));
398                assertFalse(q.remove(new Integer(i+1)));
399            }
400            assertTrue(q.isEmpty());
401        }
402    
403        /**
404         * peekFirst() returns next element, or null if empty
405       */       */
406      public void testPeekFirst() {      public void testPeekFirst() {
407          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 253  Line 415 
415      }      }
416    
417      /**      /**
418       *  peek returns next element, or null if empty       * peek() returns next element, or null if empty
419       */       */
420      public void testPeek() {      public void testPeek() {
421          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 267  Line 429 
429      }      }
430    
431      /**      /**
432       *  peekLast returns next element, or null if empty       * peekLast() returns next element, or null if empty
433       */       */
434      public void testPeekLast() {      public void testPeekLast() {
435          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 281  Line 443 
443      }      }
444    
445      /**      /**
446       * getFirst returns next getFirst, or throws NSEE if empty       * element() returns first element, or throws NSEE if empty
447         */
448        public void testElement() {
449            ArrayDeque q = populatedDeque(SIZE);
450            for (int i = 0; i < SIZE; ++i) {
451                assertEquals(i, q.element());
452                assertEquals(i, q.poll());
453            }
454            try {
455                q.element();
456                shouldThrow();
457            } catch (NoSuchElementException success) {}
458        }
459    
460        /**
461         * getFirst() returns first element, or throws NSEE if empty
462       */       */
463      public void testFirstElement() {      public void testFirstElement() {
464          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 296  Line 473 
473      }      }
474    
475      /**      /**
476       *  getLast returns next element, or throws NSEE if empty       * getLast() returns last element, or throws NSEE if empty
477       */       */
478      public void testLastElement() {      public void testLastElement() {
479          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 313  Line 490 
490    
491    
492      /**      /**
493       *  removeFirst removes next element, or throws NSEE if empty       * removeFirst() removes first element, or throws NSEE if empty
494       */       */
495      public void testRemoveFirst() {      public void testRemoveFirst() {
496          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 324  Line 501 
501              q.removeFirst();              q.removeFirst();
502              shouldThrow();              shouldThrow();
503          } catch (NoSuchElementException success) {}          } catch (NoSuchElementException success) {}
504            assertNull(q.peekFirst());
505        }
506    
507        /**
508         * removeLast() removes last element, or throws NSEE if empty
509         */
510        public void testRemoveLast() {
511            ArrayDeque q = populatedDeque(SIZE);
512            for (int i = SIZE - 1; i >= 0; --i) {
513                assertEquals(i, q.removeLast());
514            }
515            try {
516                q.removeLast();
517                shouldThrow();
518            } catch (NoSuchElementException success) {}
519            assertNull(q.peekLast());
520      }      }
521    
522      /**      /**
# Line 427  Line 620 
620      }      }
621    
622      /**      /**
623       *  toArray contains all elements       * toArray() contains all elements
624       */       */
625      public void testToArray() {      public void testToArray() {
626          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 474  Line 667 
667      }      }
668    
669      /**      /**
670       *  iterator iterates through all elements       * Iterator iterates through all elements
671       */       */
672      public void testIterator() {      public void testIterator() {
673          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 488  Line 681 
681      }      }
682    
683      /**      /**
684       *  iterator ordering is FIFO       * Iterator ordering is FIFO
685       */       */
686      public void testIteratorOrdering() {      public void testIteratorOrdering() {
687          final ArrayDeque q = new ArrayDeque();          final ArrayDeque q = new ArrayDeque();
688          q.add(new Integer(1));          q.add(one);
689          q.add(new Integer(2));          q.add(two);
690          q.add(new Integer(3));          q.add(three);
691          int k = 0;          int k = 0;
692          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
693              assertEquals(++k, it.next());              assertEquals(++k, it.next());
# Line 504  Line 697 
697      }      }
698    
699      /**      /**
700       * iterator.remove removes current element       * iterator.remove() removes current element
701       */       */
702      public void testIteratorRemove () {      public void testIteratorRemove () {
703          final ArrayDeque q = new ArrayDeque();          final ArrayDeque q = new ArrayDeque();
# Line 572  Line 765 
765      }      }
766    
767      /**      /**
768       * descendingIterator.remove removes current element       * descendingIterator.remove() removes current element
769       */       */
770      public void testDescendingIteratorRemove () {      public void testDescendingIteratorRemove () {
771          final ArrayDeque q = new ArrayDeque();          final ArrayDeque q = new ArrayDeque();
# Line 601  Line 794 
794    
795    
796      /**      /**
797       * toString contains toStrings of elements       * toString() contains toStrings of elements
798       */       */
799      public void testToString() {      public void testToString() {
800          ArrayDeque q = populatedDeque(SIZE);          ArrayDeque q = populatedDeque(SIZE);
# Line 612  Line 805 
805      }      }
806    
807      /**      /**
808       * peekFirst returns element inserted with addFirst       * A deserialized serialized deque has same elements in same order
809       */       */
810      public void testAddFirst() {      public void testSerialization() throws Exception {
811          ArrayDeque q = populatedDeque(3);          ArrayDeque q = populatedDeque(SIZE);
812          q.addFirst(four);          ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
813          assertSame(four, q.peekFirst());          ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
814      }          out.writeObject(q);
815            out.close();
816      /**  
817       * peekLast returns element inserted with addLast          ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
818       */          ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
819      public void testAddLast() {          ArrayDeque r = (ArrayDeque)in.readObject();
820          ArrayDeque q = populatedDeque(3);          assertEquals(q.size(), r.size());
821          q.addLast(four);          while (!q.isEmpty())
822          assertSame(four, q.peekLast());              assertEquals(q.remove(), r.remove());
823      }      }
824    
825  }  }

Legend:
Removed from v.1.15  
changed lines
  Added in v.1.16

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8